wowok 1.7.16 → 1.7.18

package/dist/passport.js

@@ -1,10 +1,13 @@
 var _a;
 import { Inputs } from '@mysten/sui/transactions';
-import { Protocol, ContextType, OperatorType, ValueType, SER_VALUE } from './protocol.js';
+import { Protocol, ContextType, OperatorType, ValueType, SER_VALUE, IsContextWitness, MODULES, WitnessObjectModule, WitnessForModule } from './protocol.js';
 import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray, readOption, readOptionString, deepCopy } from './utils.js';
 import { ERROR, Errors } from './exception.js';
-import { CMD_CHECK_GUARD, Guard, GuardMaker } from './guard.js';
+import { CMD_CHECK_GUARD, Guard, GUARD_QUERIES, GuardMaker } from './guard.js';
 import { bcs } from '@mysten/sui/bcs';
+import { Service } from './service.js';
+import { Arbitration } from './arbitration.js';
+import { Progress } from './progress.js';
 export class GuardParser {
     constructor(guards) {
         this.guard_list = [];
@@ -15,63 +18,176 @@ export class GuardParser {
                 // cmd already in query_list, so filter it out.
                 //console.log(g.constant); console.log(g.input)
                 g.constant.filter((i) => i.bWitness).forEach((v) => {
-                    const cmd = g.input.filter((k) => k.identifier === v.identifier && k.cmd !== undefined).map((k) => k.cmd);
                     let cited = 0;
                     g.input.forEach((k) => {
                         if (k.identifier === v.identifier)
                             cited++;
                     });
-                    ret.push({ guard: g.id, witness: undefined, identifier: v.identifier, type: v.type, cmd: cmd ?? [], cited: cited });
+                    ret.push({ guard: g.id, witness: undefined, identifier: v.identifier, ..._a.ConstantWitnessModule(v),
+                        type: v.type, cmd: v.cmd, witnessTypes: v.witness, cited: cited }); // module 很重要，需要得到
                 });
             });
             return ret;
         };
+        this.fetch_witness = async (fill) => {
+            if (!fill || fill.length === 0)
+                return;
+            // 所有需要查询的witness， 根据module字段获得
+            const witness = array_unique(fill.filter(v => v.witness_module !== undefined).map(v => v.witness));
+            if (witness.length === 0)
+                return;
+            const res = await Protocol.Instance().query_raw(witness, { showType: true, showContent: true });
+            //console.log(res);
+            const witnessObjectInfo = new Map(); // 报错witness 类型信息等
+            // 查询并填充cmd的witness
+            for (let i = 0; i < res.length; ++i) {
+                const v = res[i];
+                const type_raw = v?.data?.type ?? undefined;
+                const objectid = v?.data?.objectId ?? undefined;
+                if (!type_raw || !objectid)
+                    return;
+                const t = Protocol.Instance().object_name_from_type_repr(type_raw);
+                switch (t) {
+                    case 'Progress': {
+                        const machine = v?.data?.content?.fields?.machine;
+                        fill.filter(v => v.witness === objectid && v.witness_module === MODULES.progress).forEach(v => {
+                            v.cmd.forEach(i => {
+                                switch (i.witness) {
+                                    case ContextType.TYPE_PROGRESS_MACHINE:
+                                        i.witness_object = machine;
+                                        break;
+                                }
+                            });
+                        });
+                        witnessObjectInfo.set(objectid, { module: MODULES.progress });
+                        break;
+                    }
+                    case 'Order': {
+                        const service = v?.data?.content?.fields?.service;
+                        const machine = v?.data?.content?.fields?.machine;
+                        const progress = v?.data?.content?.fields?.progress;
+                        fill.filter(v => v.witness === objectid && v.witness_module === MODULES.order).forEach(v => {
+                            v.cmd.forEach(i => {
+                                switch (i.witness) {
+                                    case ContextType.TYPE_ORDER_MACHINE:
+                                        i.witness_object = machine;
+                                        break;
+                                    case ContextType.TYPE_ORDER_PROGRESS:
+                                        i.witness_object = progress;
+                                        break;
+                                    case ContextType.TYPE_ORDER_SERVICE:
+                                        i.witness_object = service;
+                                        break;
+                                }
+                            });
+                        });
+                        witnessObjectInfo.set(objectid, { module: MODULES.order, type: Service.parseOrderObjectType(type_raw) });
+                        break;
+                    }
+                    case 'Arb': {
+                        const arbitration = v?.data?.content?.fields?.arbitration;
+                        const order = v?.data?.content?.fields?.order;
+                        const order_res = await Protocol.Instance().query_raw([order], { showType: true, showContent: true });
+                        const service = order_res[0]?.data?.content?.fields?.service;
+                        const machine = order_res[0]?.data?.content?.fields?.machine;
+                        const progress = order_res[0]?.data?.content?.fields?.progress;
+                        const order_type = order_res[0]?.data?.type ?? undefined;
+                        fill.filter(v => v.witness === objectid && v.witness_module === MODULES.arb).forEach(v => {
+                            v.cmd.forEach(i => {
+                                switch (i.witness) {
+                                    case ContextType.TYPE_ARB_MACHINE:
+                                        i.witness_object = machine;
+                                        break;
+                                    case ContextType.TYPE_ARB_PROGRESS:
+                                        i.witness_object = progress;
+                                        break;
+                                    case ContextType.TYPE_ARB_SERVICE:
+                                        i.witness_object = service;
+                                        break;
+                                    case ContextType.TYPE_ARB_ORDER:
+                                        i.witness_object = order;
+                                        break;
+                                    case ContextType.TYPE_ARB_ARBITRATION:
+                                        i.witness_object = arbitration;
+                                        break;
+                                }
+                            });
+                        });
+                        witnessObjectInfo.set(objectid, { module: MODULES.arb, type: Arbitration.parseArbObjectType(type_raw),
+                            order: order, order_type: order_type
+                        });
+                        break;
+                    }
+                }
+            }
+            ;
+            // 检查结果的完整性
+            fill.filter(v => v.witness_module !== undefined).forEach(v => {
+                v.cmd.forEach(i => {
+                    if (i.witness && !i.witness_object) {
+                        ERROR(Errors.Fail, `fetch_witness : ${i}`);
+                    }
+                });
+            });
+            return witnessObjectInfo;
+        };
         this.done = async (fill, onPassportQueryReady) => {
             let objects = [];
+            // 填充所有的witness object
+            const witnessObjectInfo = await this.fetch_witness(fill);
             // check all witness and get all objects to query.
             this.guard_list.forEach((g) => {
                 g.constant.forEach((v) => {
                     if (v.bWitness) {
-                        const value = fill?.find((i) => i.identifier === v.identifier);
+                        const value = fill?.find((i) => i.identifier === v.identifier && i.guard === g.id);
                         if (!value) {
                             ERROR(Errors.Fail, 'done: invalid witness ' + v.identifier);
                         }
                         else {
-                            v.value = value.witness;
+                            v.value = value.witness; // 写witness
                         }
                     }
                 });
                 g.input.filter((v) => v.cmd !== undefined).forEach((i) => {
                     if (i.identifier !== undefined) {
-                        const value = g.constant.find((c) => c.identifier === i.identifier && c.type === ValueType.TYPE_ADDRESS);
-                        if (!value || !IsValidAddress(value.value))
-                            ERROR(Errors.Fail, 'done: invalid identifier ' + i.identifier);
-                        objects.push(value.value);
+                        if (IsContextWitness(i.value)) { //是否是 type witness
+                            const value = fill?.find(c => c.guard === g.id && c.identifier === i.identifier);
+                            const cmd = value?.cmd.find(c => c.cmd === i.cmd);
+                            if (!value || !cmd || !IsValidAddress(cmd.witness_object))
+                                ERROR(Errors.Fail, `witness invalid or not found:  ${i}`);
+                            objects.push(cmd.witness_object); // 将witness查询对象地址加入      
+                        }
+                        else { // self witness
+                            const value = g.constant.find((c) => c.identifier === i.identifier && c.type === ValueType.TYPE_ADDRESS);
+                            if (!value || !IsValidAddress(value.value))
+                                ERROR(Errors.Fail, 'done: invalid identifier ' + i.identifier);
+                            objects.push(value.value); // const address(witness or not)                        
+                        }
                     }
                     else {
-                        objects.push(i.value);
+                        objects.push(i.value); //@ address
                     }
                 });
             });
             if (onPassportQueryReady) {
                 if (objects.length === 0) {
-                    onPassportQueryReady(this.done_helper([]));
+                    onPassportQueryReady(this.done_helper([], fill, witnessObjectInfo));
                     return;
                 }
                 Protocol.Instance().query_raw(array_unique(objects), { showType: true }).then((res) => {
-                    onPassportQueryReady(this.done_helper(res));
+                    onPassportQueryReady(this.done_helper(res, fill, witnessObjectInfo));
                 }).catch(e => {
                     console.log(e);
                     onPassportQueryReady(undefined);
                 });
-                return undefined;
+                return;
             }
             else {
                 let res = [];
                 if (objects.length > 0) {
                     res = await Protocol.Instance().query_raw(array_unique(objects), { showType: true });
                 }
-                return this.done_helper(res);
+                return this.done_helper(res, fill, witnessObjectInfo);
             }
         };
         // create onchain query for objects : object, movecall-types, id
@@ -91,6 +207,7 @@ export class GuardParser {
         };
         this.guards = guards;
     }
+    // ============================================
     static Parse_Guard_Helper(guards, res) {
         const protocol = Protocol.Instance();
         const me = new _a(guards);
@@ -112,17 +229,122 @@ export class GuardParser {
         });
         return me;
     }
-    done_helper(res) {
+    // 检查cmd（含非witness）和witness的模块一致性，并返回模块
+    static ConstantWitnessModule(constant) {
+        let module;
+        let witness_module;
+        for (let i = 0; i < constant.cmd.length; ++i) {
+            if (constant.cmd[i].witness !== undefined) { // witness cmd
+                if (!IsContextWitness(constant.cmd[i].witness)) {
+                    ERROR(Errors.Fail, `ConstantWitnessModule witness type invalid on identifier ${constant}`);
+                }
+                const m = WitnessObjectModule(constant.cmd[i].witness);
+                if (!witness_module) {
+                    witness_module = m;
+                }
+                else {
+                    if (witness_module !== m) {
+                        ERROR(Errors.Fail, `ConstantWitnessModule wintesses modules are different on identifier ${constant}`);
+                    }
+                }
+            }
+            else {
+                const q = GUARD_QUERIES.find((q) => q.query_id == constant.cmd[i].cmd);
+                if (q) {
+                    if (!module) {
+                        module = q.module;
+                    }
+                    else {
+                        if (module !== q.module) {
+                            ERROR(Errors.Fail, `ConstantWitnessModule modules are different on identifier ${constant}`);
+                        }
+                    }
+                }
+                else {
+                    ERROR(Errors.Fail, `ConstantWitnessModule. cmd not found on identifier ${constant}`);
+                }
+            }
+        }
+        for (let i = 0; i < constant.witness.length; ++i) {
+            const m = WitnessObjectModule(constant.witness[i]);
+            if (!witness_module) {
+                witness_module = m;
+            }
+            else {
+                if (witness_module !== m) {
+                    ERROR(Errors.Fail, `ConstantWitnessModule modules are different on identifier ${constant}`);
+                }
+            }
+        }
+        return { module: module, witness_module: witness_module };
+    }
+    static AddConstantWitness(constants, identifier, type) {
+        const c = constants.find(i => i.bWitness && i.identifier === identifier);
+        if (!c)
+            ERROR(Errors.Fail, `AddConstantWitness identifer ${identifier} with witness not found`);
+        const module = _a.ConstantWitnessModule(c);
+        const m = WitnessObjectModule(type);
+        if (module.witness_module && m !== module.witness_module) {
+            ERROR(Errors.Fail, `AddConstantWitness.type module not matach ${type}`);
+        }
+        const n = c.witness.find(v => v === type);
+        c.info = { module: m };
+        if (!n)
+            c.witness.push(type);
+    }
+    static AddConstantCmd(constants, identifier, cmd) {
+        let c;
+        if (cmd.witness !== undefined) {
+            c = constants.find(i => i.bWitness && i.identifier === identifier);
+            if (!c)
+                ERROR(Errors.Fail, `AddConstantCmd identifer ${identifier} with witness not found`);
+            const module = _a.ConstantWitnessModule(c);
+            GuardMaker.checkCmdWitness(cmd.cmd, cmd.witness);
+            const m = WitnessForModule(cmd.witness);
+            if (module.witness_module && m !== module.witness_module) { // 使用module_witness字段
+                ERROR(Errors.WitnessTypeInvalid, `AddConstantCmd module not match ${identifier}`);
+            }
+            c.info = { module: m };
+        }
+        else {
+            c = constants.find(i => i.identifier === identifier);
+            if (!c)
+                ERROR(Errors.Fail, `AddConstantCmd identifer ${identifier} with witness not found`);
+            const module = _a.ConstantWitnessModule(c);
+            const m = GUARD_QUERIES.find(v => v.query_id === cmd.cmd);
+            if (!m) {
+                ERROR(Errors.Fail, `AddConstantCmd.cmd not found ${cmd}`);
+            }
+            if (module.module && m?.module !== module.module) { // 使用module字段
+                ERROR(Errors.Fail, `AddConstantCmd module not match ${identifier}`);
+            }
+        }
+        c.cmd.push(cmd); //@ 每个命令都添加进去，不考虑重复
+    }
+    done_helper(res, fill, info) {
         let query = [];
         let guards = [];
         this.guard_list.forEach(g => {
             guards.push(g.id);
+            let object_id;
             g.input.filter((v) => v.cmd !== undefined).forEach(q => {
-                let id = q.value;
-                if (!id && q.identifier !== undefined) {
-                    id = g.constant.find((i) => i.identifier == q.identifier)?.value;
+                if (q.identifier !== undefined) {
+                    if (IsContextWitness(q.value)) { //是否是 type witness
+                        const value = fill?.find(c => c.guard === g.id && c.identifier === q.identifier);
+                        object_id = value?.cmd.find(c => c.cmd === q.cmd)?.witness_object;
+                    }
+                    else { // self witness
+                        const value = g.constant.find((c) => c.identifier === q.identifier && c.type === ValueType.TYPE_ADDRESS);
+                        if (!value || !IsValidAddress(value.value)) {
+                            ERROR(Errors.Fail, `done_helper: invalid identifier ${q.identifier}`);
+                        }
+                        object_id = value?.value;
+                    }
+                }
+                else {
+                    object_id = q.value; //@ address
                 }
-                let r = res.find(r => r.data?.objectId == id);
+                let r = res.find(r => r.data?.objectId == object_id);
                 if (!r) {
                     ERROR(Errors.Fail, 'query object not match');
                 }
@@ -133,10 +355,11 @@ export class GuardParser {
                 query.push(object);
             });
         });
-        return { query: query, info: this.guard_list };
+        return { query: query, info: this.guard_list, witnessObjectInfo: info };
     }
 }
 _a = GuardParser;
+// 解析一个Guard的数据，生成树结构和表结构
 GuardParser.DeGuardObject_FromData = (guard_constants, guard_input_bytes) => {
     let constants = _a.parse_constant(guard_constants);
     // console.log(constants)
@@ -152,7 +375,7 @@ GuardParser.DeGuardObject_FromData = (guard_constants, guard_input_bytes) => {
     }
     return { object: stack.pop(), constant: constants };
 };
-/// convert guard-on-chain to js object
+/// 解析一个Guard地址，生成树结构（通过ResolveData）和表结构。 用于UI对单个guard作图
 GuardParser.DeGuardObject = async (protocol, guard) => {
     if (!IsValidAddress(guard)) {
         ERROR(Errors.IsValidAddress, 'GuardObject guard');
@@ -192,6 +415,28 @@ GuardParser.ResolveData = (constants, stack, current) => {
             current.child.push(param);
             stack.push(current);
             return;
+        case OperatorType.TYPE_SAFE_U8:
+            current.ret_type = ValueType.TYPE_U8;
+            if (stack.length < 1)
+                ERROR(Errors.Fail, 'ResolveData: TYPE_SAFE_U8');
+            var param = stack.pop();
+            if (!param.ret_type || !GuardMaker.match_u256(param.ret_type)) {
+                ERROR(Errors.Fail, 'ResolveData: TYPE_SAFE_U8 type invalid');
+            }
+            current.child.push(param);
+            stack.push(current);
+            return;
+        case OperatorType.TYPE_SAFE_U64:
+            current.ret_type = ValueType.TYPE_U64;
+            if (stack.length < 1)
+                ERROR(Errors.Fail, 'ResolveData: TYPE_SAFE_U64');
+            var param = stack.pop();
+            if (!param.ret_type || !GuardMaker.match_u256(param.ret_type)) {
+                ERROR(Errors.Fail, 'ResolveData: TYPE_SAFE_U64 type invalid');
+            }
+            current.child.push(param);
+            stack.push(current);
+            return;
         case OperatorType.TYPE_STRING_LOWERCASE:
             current.ret_type = ValueType.TYPE_STRING;
             if (stack.length < 1)
@@ -272,17 +517,17 @@ GuardParser.ResolveData = (constants, stack, current) => {
             return;
         case OperatorType.TYPE_QUERY:
             if (!current?.cmd)
-                ERROR(Errors.Fail, 'OperateParamCount: cmd invalid ' + current.type);
+                ERROR(Errors.Fail, 'ResolveData: cmd invalid ' + current.type);
             let r = Guard.GetCmd(current.cmd);
             if (!r)
-                ERROR(Errors.Fail, 'OperateParamCount: cmd not supported ' + current.type);
+                ERROR(Errors.Fail, 'ResolveData: cmd not supported ' + current.type);
             current.ret_type = r?.return;
             if (stack.length < r.parameters.length)
-                ERROR(Errors.Fail, 'OperateParamCount: cmd param lost ' + current.type);
+                ERROR(Errors.Fail, 'ResolveData: cmd param lost ' + current.type);
             r.parameters.forEach((e) => {
                 let d = stack.pop();
                 if (!d?.ret_type || d.ret_type != e) {
-                    ERROR(Errors.Fail, 'OperateParamCount: cmd param not match ' + current.type);
+                    ERROR(Errors.Fail, 'ResolveData: cmd param not match ' + current.type);
                 }
                 current.child.push(d);
             });
@@ -326,13 +571,27 @@ GuardParser.ResolveData = (constants, stack, current) => {
         case ContextType.TYPE_CONSTANT:
             let v = constants.find((e) => e.identifier == current?.identifier);
             if (!v)
-                ERROR(Errors.Fail, 'OperateParamCount: identifier  invalid ' + current.type);
+                ERROR(Errors.Fail, 'ResolveData: identifier  invalid ' + current.type);
             current.ret_type = v?.type;
             stack.push(current);
             return;
+        case ContextType.TYPE_ARB_ARBITRATION:
+        case ContextType.TYPE_ARB_MACHINE:
+        case ContextType.TYPE_ARB_ORDER:
+        case ContextType.TYPE_ARB_PROGRESS:
+        case ContextType.TYPE_ARB_SERVICE:
+        case ContextType.TYPE_ORDER_MACHINE:
+        case ContextType.TYPE_ORDER_PROGRESS:
+        case ContextType.TYPE_ORDER_SERVICE:
+        case ContextType.TYPE_PROGRESS_MACHINE: {
+            current.ret_type = ValueType.TYPE_ADDRESS;
+            stack.push(current);
+            return;
+        }
     }
-    ERROR(Errors.Fail, 'OperateParamCount: type invalid ' + current.type);
+    ERROR(Errors.Fail, 'ResolveData: type invalid ' + current.type);
 };
+// 解析一些Guards，生成parser结构。用于生成fill数据或进行passport验证。
 GuardParser.Create = async (guards) => {
     if (!IsValidArray(guards, IsValidAddress)) {
         ERROR(Errors.InvalidParam, 'GuardParser.Create: guards invalid');
@@ -399,7 +658,7 @@ GuardParser.parse_constant = (constants) => {
         const data = Uint8Array.from(v.value);
         const type = data.slice(0, 1)[0];
         if (v.bWitness) { //@ witness
-            ret.push({ identifier: v.identifier, type: type, bWitness: v.bWitness, value: undefined });
+            ret.push({ identifier: v.identifier, type: type, bWitness: v.bWitness, value: undefined, cmd: [], witness: [] });
             return;
         }
         var value = data.slice(1);
@@ -437,7 +696,7 @@ GuardParser.parse_constant = (constants) => {
             default:
                 ERROR(Errors.Fail, 'GuardObject constant type invalid:' + type);
         }
-        ret.push({ identifier: v.identifier, type: type, bWitness: v.bWitness, value: value });
+        ret.push({ identifier: v.identifier, type: type, bWitness: v.bWitness, value: value, witness: [], cmd: [] });
     });
     return ret;
 };
@@ -457,6 +716,8 @@ GuardParser.parse_bcs = (constants, chain_bytes) => {
             case OperatorType.TYPE_LOGIC_NOT:
             case OperatorType.TYPE_NUMBER_ADDRESS:
             case OperatorType.TYPE_STRING_LOWERCASE:
+            case OperatorType.TYPE_SAFE_U64:
+            case OperatorType.TYPE_SAFE_U8:
                 break;
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
@@ -474,6 +735,25 @@ GuardParser.parse_bcs = (constants, chain_bytes) => {
             case OperatorType.TYPE_LOGIC_OR:
                 value = arr.shift();
                 break;
+            case ContextType.TYPE_ARB_ARBITRATION:
+            case ContextType.TYPE_ARB_MACHINE:
+            case ContextType.TYPE_ARB_ORDER:
+            case ContextType.TYPE_ARB_PROGRESS:
+            case ContextType.TYPE_ARB_SERVICE:
+            case ContextType.TYPE_ORDER_MACHINE:
+            case ContextType.TYPE_ORDER_PROGRESS:
+            case ContextType.TYPE_ORDER_SERVICE:
+            case ContextType.TYPE_PROGRESS_MACHINE:
+                identifier = arr.shift(); // identifier
+                let v = constants.find((v) => (v.identifier == identifier) &&
+                    ((v.type == ValueType.TYPE_ADDRESS)));
+                if (!v) {
+                    ERROR(Errors.Fail, `GuardParser.parse_bcs: indentifier ${identifier} with type ${ValueType.TYPE_ADDRESS} not in constant`);
+                }
+                value = type; //@ type used
+                //@ 将witness数据加入到常量中
+                _a.AddConstantWitness(constants, identifier, type);
+                break;
             case ContextType.TYPE_CONSTANT:
                 identifier = arr.shift(); // identifier
                 break;
@@ -539,24 +819,50 @@ GuardParser.parse_bcs = (constants, chain_bytes) => {
                 break;
             case OperatorType.TYPE_QUERY:
                 let t = arr.splice(0, 1); // data-type
-                if (t[0] == ValueType.TYPE_ADDRESS) {
-                    let addr = Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(arr)).toString();
-                    arr.splice(0, 32); // address            
-                    value = addr;
-                    cmd = bcs.u16().parse(Uint8Array.from(arr.splice(0, 2))); // cmd(u16)
-                }
-                else if (t[0] == ContextType.TYPE_CONSTANT) {
-                    let id = arr.splice(0, 1); // key
-                    let v = constants.find((v) => (v.identifier == id[0]) &&
-                        ((v.type == ValueType.TYPE_ADDRESS)));
-                    if (!v) {
-                        ERROR(Errors.Fail, 'GuardObject: indentifier not in constant');
+                switch (t[0]) {
+                    case ValueType.TYPE_ADDRESS: {
+                        let addr = Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(arr)).toString();
+                        arr.splice(0, 32); // address            
+                        value = addr;
+                        cmd = bcs.u16().parse(Uint8Array.from(arr.splice(0, 2))); // cmd(u16)  
+                        break;
                     }
-                    identifier = id[0];
-                    cmd = bcs.u16().parse(Uint8Array.from(arr.splice(0, 2))); // cmd(u16)
-                }
-                else {
-                    ERROR(Errors.Fail, 'GuardObject: constant type invalid');
+                    case ContextType.TYPE_CONSTANT: {
+                        let id = arr.splice(0, 1); // key
+                        let v = constants.find((v) => (v.identifier == id[0]) &&
+                            ((v.type == ValueType.TYPE_ADDRESS)));
+                        if (!v) {
+                            ERROR(Errors.Fail, `GuardParser.parse_bcs: indentifier ${id[0]} with type ${ValueType.TYPE_ADDRESS} not in constant`);
+                        }
+                        identifier = id[0];
+                        cmd = bcs.u16().parse(Uint8Array.from(arr.splice(0, 2))); // cmd(u16)
+                        _a.AddConstantCmd(constants, identifier, { cmd: cmd }); //@ witness的cmd都添加（Self类型）
+                        break;
+                    }
+                    case ContextType.TYPE_ARB_ARBITRATION:
+                    case ContextType.TYPE_ARB_MACHINE:
+                    case ContextType.TYPE_ARB_ORDER:
+                    case ContextType.TYPE_ARB_PROGRESS:
+                    case ContextType.TYPE_ARB_SERVICE:
+                    case ContextType.TYPE_ORDER_MACHINE:
+                    case ContextType.TYPE_ORDER_PROGRESS:
+                    case ContextType.TYPE_ORDER_SERVICE:
+                    case ContextType.TYPE_PROGRESS_MACHINE: {
+                        let id = arr.splice(0, 1); // key
+                        let v = constants.find((v) => (v.identifier == id[0]) && v.bWitness &&
+                            ((v.type == ValueType.TYPE_ADDRESS))); // witness, address type
+                        if (!v) {
+                            ERROR(Errors.Fail, `GuardParser.parse_bcs: indentifier ${id[0]} with type ${ValueType.TYPE_ADDRESS} not in constant`);
+                        }
+                        identifier = id[0];
+                        cmd = bcs.u16().parse(Uint8Array.from(arr.splice(0, 2))); // cmd(u16)
+                        value = t[0]; //@ value used
+                        // 添加witness cmd（witness类型）
+                        _a.AddConstantCmd(constants, identifier, { witness: t[0], cmd: cmd });
+                        break;
+                    }
+                    default:
+                        ERROR(Errors.Fail, 'GuardObject: type invalid');
                 }
                 break;
             case ValueType.TYPE_OPTION_ADDRESS:
@@ -620,8 +926,8 @@ export class Passport {
             const res = await Protocol.Client().devInspectTransactionBlock({ sender: sender, transactionBlock: this.txb });
             return Passport.ResolveQueryRes(this.txb, res);
         };
-        if (query.info.length === 0 || query.info.length > Passport.MAX_GUARD_COUNT) {
-            ERROR(Errors.InvalidParam, 'guards');
+        if (query.info.length > Passport.MAX_GUARD_COUNT) {
+            ERROR(Errors.InvalidParam, `Passport: guards count max ${Passport.MAX_GUARD_COUNT}`);
         }
         this.txb = txb; //console.log(query)
         this.passport = this.txb.moveCall({
@@ -629,7 +935,7 @@ export class Passport {
             arguments: []
         });
         // add others guards, if any
-        query.info.forEach((g) => {
+        query.info.forEach((g, guard_index) => {
             const ids = g.constant.filter((i) => i.bWitness).map((v) => v.identifier);
             const values = g.constant.filter((i) => i.bWitness).map((v) => {
                 const bcs = Bcs.getInstance().ser(v.type, v.value);
@@ -647,6 +953,51 @@ export class Passport {
                 arguments: [this.passport, guard, this.txb.pure.vector('u8', [].slice.call(ids)),
                     this.txb.pure(bcs.vector(bcs.vector(bcs.u8())).serialize([...values]).toBytes())]
             });
+            // 对每个witness object处理所有的witness类型请求
+            const witness_objects = new Map();
+            g.constant.forEach(v => {
+                const types = [];
+                v.cmd.forEach(i => {
+                    if (i.witness && IsContextWitness(i.witness) && !types.includes(i.witness)) {
+                        types.push(i.witness);
+                    }
+                });
+                v.witness.forEach(i => {
+                    if (i && IsContextWitness(i) && !types.includes(i)) {
+                        types.push(i);
+                    }
+                });
+                if (types.length > 0) {
+                    let obj = witness_objects.get(v.value); // 用户提供的witness地址
+                    if (obj) {
+                        obj.types = array_unique(types.concat(obj.types));
+                        obj.identifier.push(v.identifier); // identifier加入
+                    }
+                    else {
+                        witness_objects.set(v.value, { types: types, identifier: [v.identifier] });
+                    }
+                }
+            });
+            // 调用witness object的witness
+            witness_objects.forEach((v, k) => {
+                const r = query.witnessObjectInfo?.get(k);
+                if (!r) {
+                    ERROR(Errors.Fail, `Passport: witness not found ${k}`);
+                }
+                switch (r?.module) {
+                    case MODULES.progress:
+                        Progress.witness(txb, k, guard_index, v.identifier, this.passport);
+                        break;
+                    case MODULES.order:
+                        Service.witness(txb, k, r.type, guard_index, v.identifier, v.types, this.passport);
+                        break;
+                    case MODULES.arb:
+                        Arbitration.witness(txb, k, r.type, guard_index, v.identifier, v.types, r.order, r.order_type, this.passport);
+                        break;
+                    default:
+                        ERROR(Errors.Fail, `Passport: witness type invalid ${r?.module}`);
+                }
+            });
         });
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         // rules: 'verify' & 'query' in turns; 'verify' at final end.