wowok_agent 0.0.1 → 0.1.3

package/src/call/demand.ts

@@ -1,13 +1,15 @@
-import { TransactionBlock, CallResponse} from 'wowok';
+import { TransactionBlock, CallResponse, IsValidArgType} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, PermissionIndex, UserDefinedIndex,
     PermissionIndexType, Demand,  WitnessFill
 } from 'wowok';
-import { OBJECT_QUERY, ObjectDemand } from '../objects';
-import { CallBase } from "./call";
+import { query_objects, ObjectDemand } from '../objects';
+import { CallBase, CallResult } from "./base";
 
-export class CallDemand extends CallBase {
+export interface CallDemand_Data {
+    object?: string; // undefined for creating a new object
+    permission?: string; 
     permission_new?: string;
-    type_parameter: string;
+    type_parameter?: string;
     guard?: {address:string; service_id_in_guard?:number};
     description?: string;
     time_expire?: {op: 'duration'; minutes:number} | {op:'set'; time:number};
@@ -15,117 +17,129 @@ export class CallDemand extends CallBase {
     present?: {service: string | number; recommend_words:string; service_pay_type:string, guard?:string | 'fetch'}; // guard is the present guard of Demand
     reward?: string; // rerward the service
     refund?: boolean;
-    constructor(type_parameter:string, object: string | 'new' = 'new') { 
-        super(object)
-        this.type_parameter = type_parameter 
+}
+export class CallDemand extends CallBase {
+    data: CallDemand_Data;
+    constructor(data: CallDemand_Data) {
+        super();
+        this.data = data;
     }
-    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
-        if (!this.type_parameter) ERROR(Errors.InvalidParam, 'type_parameter')
+    async call(account?:string) : Promise<CallResult> {
+        if (!this.data?.type_parameter || !IsValidArgType(this.data.type_parameter)) {
+            ERROR(Errors.IsValidArgType, 'demand.type_parameter')
+        }
+
         var checkOwner = false; const guards : string[] = [];
         const perms : PermissionIndexType[] = []; 
 
-        if (this?.permission && IsValidAddress(this.permission)) {
-            if (this?.object === 'new') {
+        if (this.data?.permission && IsValidAddress(this.data.permission)) {
+            if (!this.data?.object) {
                 perms.push(PermissionIndex.demand)
             }
-            if (this?.permission_new !== undefined) {
+            if (this.data?.permission_new !== undefined) {
                 checkOwner = true;
             }
-            if (this?.description !== undefined && this.object !== 'new') {
+            if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.demand_description)
             }
-            if (this?.time_expire !== undefined && this.object !== 'new') {
+            if (this.data?.time_expire !== undefined && this.data.object) {
                 perms.push(PermissionIndex.demand_expand_time)
             }
-            if (this?.guard !== undefined) {
+            if (this.data?.guard !== undefined) {
                 perms.push(PermissionIndex.demand_guard)
             }
-            if (this?.reward !== undefined) {
+            if (this.data?.reward !== undefined) {
                 perms.push(PermissionIndex.demand_yes)
             }
-            if (this?.refund) {
+            if (this.data?.refund) {
                 perms.push(PermissionIndex.demand_refund)
             }
-            if (this?.present?.guard !== undefined) {
-                if (IsValidAddress(this.present.guard)) {
-                    guards.push(this.present.guard)
-                } else if (IsValidAddress(this?.object)) {
-                    const r = await OBJECT_QUERY.objects({objects:[this.object], showContent:true});
-                    if (r?.objects && r?.objects[0]?.type === 'Demand') {
-                        const obj = (r?.objects[0] as ObjectDemand);
-                        if (obj?.guard) {
-                            guards.push(obj?.guard.object);
+            if (this.data?.present?.guard !== undefined) {
+                if (IsValidAddress(this.data.present.guard)) {
+                    guards.push(this.data.present.guard)
+                } else {
+                    if (!this.data.object) { // new
+                        if (this.data?.guard?.address && IsValidAddress(this.data?.guard.address)) {
+                            guards.push(this.data.guard.address)
+                        }
+                    } else {
+                        const r = await query_objects({objects:[this.data.object], showContent:true});
+                        if (r?.objects && r?.objects[0]?.type === 'Demand') {
+                            const obj = (r?.objects[0] as ObjectDemand);
+                            if (obj?.guard) {
+                                guards.push(obj?.guard.object);
+                            }
                         }
                     }
                 }
             }
-            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+            return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
         return this.exec(account);
     }
     protected async operate(txb:TransactionBlock, passport?:PassportObject) {
         let obj : Demand | undefined ; let permission: any;
 
-        if (this.object === 'new') {
-            if (!this?.permission || !IsValidAddress(this?.permission)) {
+        if (!this.data.object) {
+            if (!this.data?.permission || !IsValidAddress(this.data?.permission)) {
                 permission = Permission.New(txb, '');
             }
             
-            if (this.time_expire !== undefined) {
-                obj = Demand.New(txb, this.type_parameter, this.time_expire?.op === 'duration' ? true : false, 
-                    this.time_expire?.op === 'duration' ? this.time_expire.minutes : this.time_expire?.time,
-                    permission ? permission.get_object(): this?.permission, this?.description??'', permission?undefined:passport)
+            if (this.data.time_expire !== undefined) {
+                obj = Demand.New(txb, this.data.type_parameter!, this.data.time_expire?.op === 'duration' ? true : false, 
+                    this.data.time_expire?.op === 'duration' ? this.data.time_expire.minutes : this.data.time_expire?.time,
+                    permission ? permission.get_object(): this.data?.permission, this.data?.description??'', permission?undefined:passport)
             } else {
-                obj = Demand.New(txb, this.type_parameter, true, 30*24*60, // 30days default
-                    permission ? permission.get_object(): this?.permission, this?.description??'', permission?undefined:passport)       
+                obj = Demand.New(txb, this.data.type_parameter!, true, 30*24*60, // 30days default
+                    permission ? permission.get_object(): this.data?.permission, this.data?.description??'', permission?undefined:passport)       
             }
         } else {
-            if (IsValidAddress(this.object) && this.type_parameter && this.permission && IsValidAddress(this?.permission)) {
-                obj = Demand.From(txb, this.type_parameter, this.permission, this.object)
+            if (IsValidAddress(this.data.object) && this.data.type_parameter && this.data.permission && IsValidAddress(this.data?.permission)) {
+                obj = Demand.From(txb, this.data.type_parameter, this.data.permission, this.data.object)
             }
         }
 
         if (obj) {
-            if (this?.description !== undefined && this.object !== 'new') {
-                obj?.set_description(this.description, passport);
+            if (this.data?.description !== undefined && this.data.object) {
+                obj?.set_description(this.data.description, passport);
             }
-            if (this?.time_expire !== undefined && this.object !== 'new') {
-                obj?.expand_time(this.time_expire.op === 'duration' ? true : false, 
-                    this.time_expire.op === 'duration' ? this.time_expire.minutes : this.time_expire.time, passport)
+            if (this.data?.time_expire !== undefined && this.data.object) {
+                obj?.expand_time(this.data.time_expire.op === 'duration' ? true : false, 
+                    this.data.time_expire.op === 'duration' ? this.data.time_expire.minutes : this.data.time_expire.time, passport)
             }
-            if (this?.bounty !== undefined) {
-                if (this.bounty.op === 'add') {
-                    let deposit : any | undefined; let b = BigInt(this.bounty.balance);
+            if (this.data?.bounty !== undefined) {
+                if (this.data.bounty.op === 'add') {
+                    let deposit : any | undefined; let b = BigInt(this.data.bounty.balance);
                     if (b > BigInt(0)) {
-                        if (this.type_parameter === '0x2::sui::SUI' || this.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
+                        if (this.data.type_parameter === '0x2::sui::SUI' || this.data.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
                             deposit = txb.splitCoins(txb.gas, [b])[0];
-                        } else if (this?.bounty?.object) {
-                            deposit = txb.splitCoins(this.bounty.object, [b])[0];
+                        } else if (this.data?.bounty?.object) {
+                            deposit = txb.splitCoins(this.data.bounty.object, [b])[0];
                         }
                         if (deposit) {
                             obj?.deposit(deposit);                              
                         }
                     }
-                } else if (this.bounty.op === 'refund') {
+                } else if (this.data.bounty.op === 'refund') {
                     obj?.refund(passport);
-                } else if (this.bounty.op === 'reward') {
-                    obj?.yes(this.bounty.service, passport);
+                } else if (this.data.bounty.op === 'reward') {
+                    obj?.yes(this.data.bounty.service, passport);
                 }
             }
-            if (this?.present !== undefined) {
+            if (this.data?.present !== undefined) {
                 //@ demand guard and its passport, if set
-                obj?.present(this.present.service, this.present.service_pay_type, this.present.recommend_words, passport);
+                obj?.present(this.data.present.service, this.data.present.service_pay_type, this.data.present.recommend_words, passport);
             }
-            if (this?.guard !== undefined) {
-                obj?.set_guard(this.guard.address, this.guard?.service_id_in_guard ?? undefined, passport)
+            if (this.data?.guard !== undefined) {
+                obj?.set_guard(this.data.guard.address, this.data.guard?.service_id_in_guard ?? undefined, passport)
             }
-            if (this?.permission_new !== undefined ) {
-                obj?.change_permission(this.permission_new);
+            if (this.data?.permission_new !== undefined ) {
+                obj?.change_permission(this.data.permission_new);
             }
             if (permission) {
                 permission.launch();
             }
-            if (this.object === 'new') {
+            if (!this.data.object) {
                 obj?.launch();
             }
         }

package/src/call/guard.ts

@@ -0,0 +1,264 @@
+
+/**
+ *  generate and launch a guard
+ */
+
+import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, 
+    concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead, CallResponse, 
+    IsValidDesription} from "wowok";
+import { Account } from "../account";
+import { CallBase, CallResult } from "./base";
+
+export interface GuardConst {
+    identifier: number; // 1-255, the same identifier to represent the same data in different nodes
+    bWitness: boolean; // witness(verifiee provides while verifying in the future) or normal(verifier provides now)
+    value_type: ValueType; // data value type
+    value?: any; // if bWitness true, value ignores; otherwise, data.
+}
+
+// parameters: Child nodes arranged in parameter order, with each child node providing the type and data for that parameter
+export type GuardNode = { identifier: number; } // Data from GuardConst
+    | {query: number | string, object: string | number; parameters: GuardNode[];} // object: address string or identifier in GuardConst that value_type = ValueType.address
+    | {logic: OperatorType.TYPE_LOGIC_AS_U256_GREATER | OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL
+        | OperatorType.TYPE_LOGIC_AS_U256_LESSER | OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL 
+        | OperatorType.TYPE_LOGIC_AS_U256_EQUAL | OperatorType.TYPE_LOGIC_EQUAL | OperatorType.TYPE_LOGIC_HAS_SUBSTRING 
+        | OperatorType.TYPE_LOGIC_ALWAYS_TRUE | OperatorType.TYPE_LOGIC_NOT 
+        | OperatorType.TYPE_LOGIC_AND | OperatorType.TYPE_LOGIC_OR;  parameters: GuardNode[];}
+    | {calc: OperatorType.TYPE_NUMBER_ADD | OperatorType.TYPE_NUMBER_DEVIDE | OperatorType.TYPE_NUMBER_MOD 
+        | OperatorType.TYPE_NUMBER_MULTIPLY | OperatorType.TYPE_NUMBER_SUBTRACT; parameters: GuardNode[];}
+    | {value_type: ValueType; value:any; } // Data 
+    | {context: ContextType.TYPE_CLOCK | ContextType.TYPE_GUARD | ContextType.TYPE_SIGNER }; // Data from run-time environment
+
+export interface CallGuard_Data {
+    description: string;
+    table: GuardConst[]; //  data used by multiple logical guard nodes
+    root: GuardNode; // root must return ValueType.TYPE_BOOL     
+}
+export class CallGuard extends CallBase {
+    data: CallGuard_Data;
+    constructor(data: CallGuard_Data) {
+        super();
+        this.data = data;
+    }
+    async call(account?:string) : Promise<CallResult> {
+        if (!this.data?.root) {
+            ERROR(Errors.InvalidParam, 'guard root node invalid')
+        }
+        if (!IsValidDesription(this.data?.description)) {
+            ERROR(Errors.IsValidDesription, 'build_guard - '+this.data.description)
+        }
+    
+        // check const
+        this.data.table.forEach(v => {
+            if (!IsValidU8(v.identifier) || v.identifier < 1) ERROR(Errors.InvalidParam, 'table.identifer invalid');
+            if (!v.bWitness && v.value === undefined) ERROR(Errors.InvalidParam, 'table.value');
+        })
+    
+        if (hasDuplicates(this.data.table.map(v => v.identifier))) {
+            ERROR(Errors.InvalidParam, 'table.identifer duplicates')
+        }
+    
+        // check root
+        var output : Uint8Array[]= [];
+        buildNode(this.data.root!, ValueType.TYPE_BOOL, this.data.table, output);
+        const bytes = (concatenate(Uint8Array, ...output) as Uint8Array); 
+        const txb = new TransactionBlock();
+    
+        console.log(bytes)
+        const obj = txb.moveCall({
+            target: Protocol.Instance().guardFn('new') as FnCallType,
+            arguments: [txb.pure.string(this.data.description), txb.pure.vector('u8', [].slice.call(bytes.reverse()))],  
+        });
+        this.data.table.forEach((v) => {
+            if (v.bWitness) {
+                const n = new Uint8Array(1); n.set([v.value_type], 0);
+                txb.moveCall({
+                    target:Protocol.Instance().guardFn("constant_add") as FnCallType,
+                    arguments:[txb.object(obj), txb.pure.u8(v.identifier), txb.pure.bool(true), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(false)]
+                }) 
+            } else {
+                const tmp = Uint8Array.from(Bcs.getInstance().ser(v.value_type, v.value));
+                const n = insertAtHead(tmp, v.value_type);
+                txb.moveCall({
+                    target:Protocol.Instance().guardFn("constant_add") as FnCallType,
+                    arguments:[txb.object(obj), txb.pure.u8(v.identifier), txb.pure.bool(false),  txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(false)]
+                }) 
+            }
+        })
+        txb.moveCall({
+            target:Protocol.Instance().guardFn("create") as FnCallType,
+            arguments:[txb.object(obj)]
+        });
+    
+        const pair = Account.Instance().get_pair(account, true);
+        if (!pair) ERROR(Errors.Fail, 'account invalid')
+    
+        return await Protocol.Client().signAndExecuteTransaction({
+            transaction: txb, 
+            signer: pair!,
+            options:{showObjectChanges:true},
+        });
+    }
+}
+
+//export const MAX_CHILD_NODE_COUNT = 6;
+
+const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'variable', table:GuardConst[], output:Uint8Array[]) => {
+    const node: any = guard_node as any;
+    if (node?.identifier !== undefined) {
+        console.log(node)
+        const f = table.find(v=>v.identifier === node.identifier);
+        if (f) {
+            checkType(f.value_type, type_required, node);
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT)); 
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.identifier))
+            console.log(2)
+        } else {
+            ERROR(Errors.InvalidParam, 'node identifier - ' + node.toString());
+        }
+    } else if (node?.query !== undefined) {
+        var q: any[] | undefined;
+        if (typeof(node.query === 'string')) {
+            q = GUARD_QUERIES.find(v=>v[1] === node.query);
+        } else if (typeof(node.query === 'number')) {
+            q = GUARD_QUERIES.find(v=>v[2] === node.query);
+        }
+
+        if (q) {
+            checkType(q[4], type_required, node); // Return type checking
+            if ((q[3]).length === node.parameters.length) {
+                for (let i = node.parameters.length - 1; i >= 0; --i) { // stack: first in, last out
+                    buildNode(node.parameters[i], q[3][i], table, output); // Recursive check
+                }
+            } else {
+                ERROR(Errors.InvalidParam, 'node query parameters length not match - ' + node.toString())
+            }
+        } else {
+            ERROR(Errors.InvalidParam, 'node query not found - ' + node.toString());
+        }
+
+        if (typeof(node.object) === 'string') {
+            if (!IsValidAddress(node.object)) {
+                ERROR(Errors.InvalidParam, 'node object from address string - ' + node.toString())
+            }
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ValueType.TYPE_ADDRESS)); 
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, node.object)); // object address             
+        } else {
+            const f = table.find(v=>v.identifier === node.object);
+            if (f) {
+                checkType(f.value_type, ValueType.TYPE_ADDRESS, node);
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.object)); // object id
+            } else {
+                ERROR(Errors.InvalidParam, 'node object from identifier - ' + node.toString());
+            }
+        }
+    } else if (node?.logic !== undefined) {
+        checkType(ValueType.TYPE_BOOL, type_required, node); // bool
+        switch (node?.logic) {
+            case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
+                if (node.parameters.length !== 0) ERROR(Errors.InvalidParam, 'node logic parameters length must be 0'+ node.toString());
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                break;
+            case OperatorType.TYPE_LOGIC_AND:
+            case OperatorType.TYPE_LOGIC_OR:
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ node.toString()); 
+                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+            case OperatorType.TYPE_LOGIC_NOT:
+                if (node.parameters.length !== 1) ERROR(Errors.InvalidParam, 'node logic parameters length must be 1'+ node.toString());
+                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                break;
+            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:
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ node.toString());
+                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); 
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+            case OperatorType.TYPE_LOGIC_EQUAL:
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ node.toString());
+                var any_type: any = 'variable';
+                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, any_type, table, output)); 
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;               
+            case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ node.toString());
+                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); 
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+        }
+    } else if (node?.calc !== undefined) {
+        checkType(ValueType.TYPE_U256, type_required, node);
+        if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node calc parameters length must >= 2'+ node.toString());
+        (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); 
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.calc)); // TYPE 
+        output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+    } else if (node?.value_type !== undefined) {
+        checkType(node?.value_type, type_required, node);
+        if (node?.value === undefined) ERROR(Errors.InvalidParam, 'node value undefined - ' + node.toString());
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.value_type)); // TYPE
+
+        if (node.value_type == ValueType.TYPE_STRING || node.value_type === ValueType.TYPE_VEC_U8) {
+            if (typeof(node.value) == 'string') {
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_STRING, node.value));
+            } else {
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, node.value));
+            }
+        } else {
+            output.push(Bcs.getInstance().ser(node?.value_type, node.value));            
+        }
+    } else if (node?.context !== undefined) {
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.context));
+        switch (node.context) {
+            case ContextType.TYPE_CLOCK:
+                checkType(ValueType.TYPE_U64, type_required, node);
+                break;
+            case ContextType.TYPE_GUARD: 
+            case ContextType.TYPE_SIGNER:
+                checkType(ValueType.TYPE_ADDRESS, type_required, node);
+                break;
+        }
+    } else {
+        ERROR(Errors.InvalidParam, 'node - ' + node.toString())
+    }
+}
+
+
+const checkType = (type: ValueType | ContextType.TYPE_CLOCK | ContextType.TYPE_GUARD | ContextType.TYPE_SIGNER, 
+    type_required:ValueType | 'number' | 'variable', node?: GuardNode) => {
+    if (type_required === 'variable') {
+        type_required = type as number;
+    } else if (type_required === 'number') {
+        if (type === ValueType.TYPE_U128 || type === ValueType.TYPE_U256 || type === ValueType.TYPE_U8 ||
+            type === ValueType.TYPE_U64 || type === ContextType.TYPE_CLOCK) {
+                return
+            }
+    } else if (type_required === ValueType.TYPE_ADDRESS) {
+        if (type === ContextType.TYPE_SIGNER || type === ContextType.TYPE_GUARD) {
+            return
+        }
+    } /*else if (type_required === ValueType.TYPE_STRING) {
+        if (type === ValueType.TYPE_VEC_U8) {
+            return
+        }
+    } else if (type_required === ValueType.TYPE_VEC_U8) {
+        if (type === ValueType.TYPE_STRING) {
+            return 
+        }
+    } */
+
+    if (type !== type_required) {
+        var str = '';
+        if (node) str = ' - ' + node.toString();
+        ERROR(Errors.InvalidParam, 'checkType: ' + type + ' require type: ' + type_required + str);
+    }
+}