wowok 1.3.13 → 1.4.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.3.13",
+  "version": "1.4.16",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/exception.ts

@@ -25,6 +25,6 @@ export enum Errors {
 }
 
 export const ERROR = (error:Errors, info?:any) =>  {
-    const e = error + info ? (': ' + info) : '';
+    const e = error + info ? (' ' + info) : '';
     throw e;
 }

package/src/guard.ts

@@ -2,7 +2,7 @@
 
 import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, ConstantType, SER_VALUE} from './protocol';
 import { concatenate, array_equal } from './utils';
-import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase } from './utils';
+import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase, insertAtHead } from './utils';
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
@@ -59,19 +59,19 @@ export class Guard {
                 if (!v.witness) {
                     ERROR(Errors.InvalidParam, 'constants type')
                 }
-
+                const n = insertAtHead(v.witness!, v.type);
                 txb.moveCall({
                     target:Protocol.Instance().GuardFn("constant_add") as FnCallType,
-                    arguments:[guard, txb.pure.u8(k), txb.pure.u8(v.type), txb.pure.vector('u8', [].slice.call(v.witness)), txb.pure.bool(true)]
+                    arguments:[guard, txb.pure.u8(k), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(true)]
                 })            
             } else {
                 if (!v.value)   {
                     ERROR(Errors.InvalidParam, 'constants type')
                 }
-    
+                const n = insertAtHead(v.value!, v.type);
                 txb.moveCall({
                     target:Protocol.Instance().GuardFn("constant_add") as FnCallType,
-                    arguments:[guard, txb.pure.u8(k), txb.pure.u8(v.type), txb.pure.vector('u8', [].slice.call(v.value)), txb.pure.bool(true)]
+                    arguments:[guard, txb.pure.u8(k), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(true)]
                 }) 
             }
         });
@@ -115,20 +115,29 @@ export class Guard {
         [MODULES.repository, 'Value Type of Policy',  15, [ValueType.TYPE_STRING], ValueType.TYPE_U8, 'Data types defined by consensus policy.', 'Input:the policy name'],
         [MODULES.repository, 'Contains Data for An Address', 16, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether data exists at a certain address?', 'Input:address'],   
         [MODULES.repository, 'Contains Data', 17, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does it contain data for a certain field of an address?', 'Input 1:address, Input 2:the field name'],
-        [MODULES.repository, 'Data without Type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address and does not contain data type information.', 'Input 1:address, Input 2:the field name'],       
-        [MODULES.repository, 'Value', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address, and the first byte contains data type information.', 'Input 1:address, Input 2:the field name'],
+        [MODULES.repository, 'Raw data without Type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address and does not contain data type information.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Raw data', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U8, 'Data for a field at an address, and the first byte contains data type information.', 'Input 1:address, Input 2:the field name'],
         [MODULES.repository, 'Type', 20, [], ValueType.TYPE_U8, 'The repository Type. 0: Normal; 1: Wowok greenee.'],   
         [MODULES.repository, 'Policy Mode', 21, [], ValueType.TYPE_U8, 'Policy Mode. 0: Free mode;  1: Strict mode.'],   
         [MODULES.repository, 'Reference Count', 22, [], ValueType.TYPE_U64, 'The number of times it is referenced by other objects.'],   
         [MODULES.repository, 'Is Referenced by An Object', 23, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is it referenced by an object?', 'Input:address'],   
+        [MODULES.repository, 'Data Number', 24, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_U256, 'Data for a field at an address and get unsigned integer type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data String', 25, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_STRING, 'Data for a field at an address and get string type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data Address', 26, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'Data for a field at an address and get address type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data Bool', 27, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Data for a field at an address and get bool type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data Number Vector', 28, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_U256, 'Data for a field at an address and get unsigned integer vector type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data String Vector', 29, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_STRING, 'Data for a field at an address and get string vector type data.', 'Input 1:address, Input 2:the field name'],  
+        [MODULES.repository, 'Data Address Vector', 30, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_ADDRESS, 'Data for a field at an address and get address vector type data.', 'Input 1:address, Input 2:the field name'],       
+        [MODULES.repository, 'Data Bool Vector', 31, [ValueType.TYPE_ADDRESS, ValueType.TYPE_STRING], ValueType.TYPE_VEC_BOOL, 'Data for a field at an address and get bool vector type data.', 'Input 1:address, Input 2:the field name'],            
+
         // , means that data fields and data outside the consensus policy definition are allowed to be written
         // , means that only data fields and data defined by the consensus policy are allowed to be written.
-        [MODULES.machine, 'Permission', 31, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
-        [MODULES.machine, 'Paused', 32, [], ValueType.TYPE_BOOL, 'Pause the creation of new Progress?'],
-        [MODULES.machine, 'Published', 33, [], ValueType.TYPE_BOOL, 'Is it allowed to create Progress?'],
-        [MODULES.machine, 'Is Consensus Repository', 34, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is a consensus repository?', 'Input:adddress'],
-        [MODULES.machine, 'Has Endpoint', 35, [], ValueType.TYPE_BOOL, 'Is the endpoint set?'],   
-        [MODULES.machine, 'Endpoint', 36, [], ValueType.TYPE_STRING, 'Endpoint url/ipfs.'],
+        [MODULES.machine, 'Permission', 41, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
+        [MODULES.machine, 'Paused', 42, [], ValueType.TYPE_BOOL, 'Pause the creation of new Progress?'],
+        [MODULES.machine, 'Published', 43, [], ValueType.TYPE_BOOL, 'Is it allowed to create Progress?'],
+        [MODULES.machine, 'Is Consensus Repository', 44, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is a consensus repository?', 'Input:adddress'],
+        [MODULES.machine, 'Has Endpoint', 45, [], ValueType.TYPE_BOOL, 'Is the endpoint set?'],   
+        [MODULES.machine, 'Endpoint', 46, [], ValueType.TYPE_STRING, 'Endpoint url/ipfs.'],
     
         [MODULES.progress, 'Machine', 51, [], ValueType.TYPE_ADDRESS, 'The Machine object that created this Progress.'],       
         [MODULES.progress, 'Current Node', 52, [], ValueType.TYPE_STRING, 'The name of the currently running node.'],
@@ -295,7 +304,7 @@ export class Guard {
     }
 
     static StringOptions = () : Guard_Options[] => {
-        return [...Guard.CmdFilter(ValueType.TYPE_VEC_U8), ...Guard.CmdFilter(ValueType.TYPE_STRING)].map((v) => {
+        return [...Guard.CmdFilter(ValueType.TYPE_STRING)].map((v) => {
             return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])};
         });
     }
@@ -362,11 +371,12 @@ export class GuardConstantHelper {
         } 
     }
     
-    static add_constant(constants:GuardConstant, identifier:number, type:ValueType|ContextType, value:any, bNeedSerialize=true) {
+    static add_constant(constants:GuardConstant, identifier:number, type:ValueType, value:any, bNeedSerialize=true) {
+        const e = SER_VALUE.find((v:any)=>v.type===type)?.name ?? '' + ' invalid';
         if (!GuardConstantHelper.IsValidIndentifier(identifier)) {
             ERROR(Errors.InvalidParam, 'add_constant identifier')
         }
-        if (!value) {
+        if (value === undefined) {
             ERROR(Errors.InvalidParam, 'add_constant value')
         }
     
@@ -390,17 +400,20 @@ export class GuardConstantHelper {
             case ValueType.TYPE_VEC_U128:
             case ValueType.TYPE_VEC_U256:
             case ValueType.TYPE_STRING:  
-            case ValueType.TYPE_VEC_U8: 
+            case ValueType.TYPE_VEC_U8:
+            case ValueType.TYPE_OPTION_STRING:
+            case ValueType.TYPE_OPTION_VEC_U8:
+            case ValueType.TYPE_VEC_STRING:
                 let ser = SER_VALUE.find(s=>s.type==type);
-                if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type');
+                if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type:'+e);
                 if (bNeedSerialize) {
-                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.type as number, value)}) 
+                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser(type, value)}) 
                 } else {
                     constants.set(identifier, {type:type, value:value}) 
                 }
                 return    
             default:
-                ERROR(Errors.Fail, 'add_constant  serialize not impl yet')
+                ERROR(Errors.Fail, 'add_constant  serialize not impl yet:'+e)
         }
     }
 }
@@ -421,7 +434,7 @@ export class GuardMaker {
 
     add_constant(type:ConstantType, value:any, identifier?:number, bNeedSerialize=true) : number {
         if (identifier === undefined) identifier = GuardMaker.get_index();
-        if (type == ContextType.TYPE_WITNESS_ID) {
+        if (type === ContextType.TYPE_WITNESS_ID) {
             // add witness to constant
             GuardConstantHelper.add_future_constant(this.constant, identifier, value, undefined, bNeedSerialize);
         } else {
@@ -431,7 +444,7 @@ export class GuardMaker {
     }
 
     private  serValueParam(type:ValueType, param?:any) {
-        if (!param) ERROR(Errors.InvalidParam, 'param');
+        if (param === undefined) ERROR(Errors.InvalidParam, 'param');
         this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
         let ser = SER_VALUE.find(s=>s.type==type);
         if (!ser) ERROR(Errors.Fail, 'serValueParam: invalid type');
@@ -441,6 +454,8 @@ export class GuardMaker {
 
     // serialize const & data
     add_param(type:ValueType | ContextType, param?:any) : GuardMaker {
+        const e = SER_VALUE.find((v:any)=>v.type===type)?.name ?? '' + ' invalid';
+
         switch(type)  {
         case ValueType.TYPE_ADDRESS: 
         case ValueType.TYPE_BOOL:
@@ -464,7 +479,7 @@ export class GuardMaker {
             break;
         case ValueType.TYPE_STRING:
         case ValueType.TYPE_VEC_U8:
-            if (!param) ERROR(Errors.InvalidParam, 'param');
+            if (!param) ERROR(Errors.InvalidParam, 'param:'+e);
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); //@ USE VEC-U8
             if (typeof(param) == 'string') {
                 this.data.push(Bcs.getInstance().ser(ValueType.TYPE_STRING, param));
@@ -482,56 +497,56 @@ export class GuardMaker {
             this.type_validator.push(ValueType.TYPE_U64);
             break;
         case ContextType.TYPE_WITNESS_ID:
-            if (!param) ERROR(Errors.InvalidParam, 'param');
+            if (!param) ERROR(Errors.InvalidParam, 'param:'+e);
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, param));
             this.type_validator.push(ValueType.TYPE_ADDRESS);
             break;   
         case ContextType.TYPE_CONSTANT:
             if (!param) {
-                ERROR(Errors.InvalidParam, 'param invalid');
+                ERROR(Errors.InvalidParam, 'param invalid:'+e);
             }
             if (typeof(param) != 'number' || !IsValidInt(param) || param > 255) {
-                ERROR(Errors.InvalidParam, 'add_param param');
+                ERROR(Errors.InvalidParam, 'add_param param:'+type);
             }
             
             var v = this.constant.get(param);
-            if (!v) ERROR(Errors.Fail, 'identifier not in constant');
+            if (!v) ERROR(Errors.Fail, 'identifier not in constant:'+e);
             this.type_validator.push(v!.type);
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, param));
             break;
         default:
-            ERROR(Errors.InvalidParam, 'add_param type' + type);
+            ERROR(Errors.InvalidParam, 'add_param type:'+e);
         };
         return this;
     }
 
     // object_address_from: string for static address; number as identifier  inconstant
-    add_query(module:MODULES, query_name:string, object_address_from:string | number, bWitness:boolean=false) : GuardMaker {
+    add_query(module:MODULES, query_name:string, object_address_from:string | number, bWitness:boolean=false) : GuardMaker {        
         let query_index = Guard.QUERIES.findIndex((q) => { return q[0] ==  module && q[1]  == query_name})
         if (query_index == -1)  {
-            ERROR(Errors.InvalidParam, 'query_name');
+            ERROR(Errors.InvalidParam, 'query_name:'+query_name);
         }
 
         if (typeof(object_address_from) == 'number' ) {
             if (!GuardConstantHelper.IsValidIndentifier(object_address_from)) {
-                ERROR(Errors.InvalidParam, 'object_address_from');
+                ERROR(Errors.InvalidParam, 'object_address_from:'+query_name);
             }
         } else {
             if (!IsValidAddress(object_address_from)) {
-                ERROR(Errors.InvalidParam, 'object_address_from');
+                ERROR(Errors.InvalidParam, 'object_address_from:'+query_name);
             }
         }
 
         let offset = this.type_validator.length - Guard.QUERIES[query_index][3].length;
         if (offset < 0) { 
-            ERROR(Errors.InvalidParam, 'query_name');
+            ERROR(Errors.InvalidParam, 'query_name:'+query_name);
         }
 
         let types = this.type_validator.slice(offset);
         if (!array_equal(types, Guard.QUERIES[query_index][3])) { // type validate 
-            ERROR(Errors.Fail, 'array_equal');
+            ERROR(Errors.Fail, 'array_equal:'+query_name);
         }
         
         this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_QUERY)); // QUERY TYPE
@@ -541,12 +556,12 @@ export class GuardMaker {
             this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, object_address_from)); // object address            
         } else {
             let v =  this.constant.get(object_address_from);
-            if (!v) ERROR(Errors.Fail, 'object_address_from not in constant');
+            if (!v) ERROR(Errors.Fail, 'object_address_from not in constant:'+query_name);
             if ((bWitness && v?.type == ContextType.TYPE_WITNESS_ID) || (!bWitness && v?.type == ValueType.TYPE_ADDRESS)) {
                 this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
                 this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, object_address_from)); // object identifer in constants
             } else {
-                ERROR(Errors.Fail, 'type bWitness not match')
+                ERROR(Errors.Fail, 'type bWitness not match:'+query_name)
             }
         }
 
@@ -556,7 +571,10 @@ export class GuardMaker {
         return this;
     }
 
-    add_logic(type:OperatorType) : GuardMaker {
+    add_logic(type:OperatorType, param:number=2) : GuardMaker {
+        var e:any = LogicsInfo.find((v:any) => v[0] === type);
+        if (e) { e=e[1] }
+
         let splice_len = 2;
         let ret = ValueType.TYPE_BOOL;
         switch (type) {
@@ -565,43 +583,41 @@ export class GuardMaker {
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
             case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
-                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) { ERROR(Errors.Fail, 'type_validator check') }
-                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) { ERROR(Errors.Fail, 'type_validator check')  }
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
+                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
+                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
                 break;
             case OperatorType.TYPE_LOGIC_EQUAL:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
+                if (GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1]) && 
+                    GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) {
+                    break;
+                } else if (this.type_validator[this.type_validator.length - 1] === this.type_validator[this.type_validator.length - 2]) {
+                    break;
+                } else {
+                    ERROR(Errors.Fail, 'type_validator check:' + e)  ;
+                }
                 break;
             case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
+                if (this.type_validator[this.type_validator.length - 1] !== ValueType.TYPE_STRING || 
+                    this.type_validator[this.type_validator.length - 2] !== ValueType.TYPE_STRING) {
+                        ERROR(Errors.Fail, 'type_validator check:' + e)  ;
+                }
                 break;
             case OperatorType.TYPE_LOGIC_NOT:
                 splice_len =  1;
-                if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length') }
-                if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
+                if (this.type_validator.length < splice_len) { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
                 break;
             case OperatorType.TYPE_LOGIC_AND:
-            case OperatorType.TYPE_LOGIC_OR:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
-                if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -2] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                break;
-            case OperatorType.TYPE_LOGIC_AND3:
-            case OperatorType.TYPE_LOGIC_OR3:
-                splice_len =  3;
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
-                if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -2] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -3] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                break;
-            case OperatorType.TYPE_LOGIC_AND4:
-            case OperatorType.TYPE_LOGIC_OR4:
-                splice_len =  4;
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
-                if (this.type_validator[this.type_validator.length -1] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -2] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -3] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (this.type_validator[this.type_validator.length -4] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check')  }
+            case OperatorType.TYPE_LOGIC_OR: //@ logics count
+                if (!param || param < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = param!;
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                for (let i = 1; i <= splice_len; ++i) {
+                    if (this.type_validator[this.type_validator.length -i] != ValueType.TYPE_BOOL) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
+                }
                 break;
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
                 break;
@@ -610,15 +626,19 @@ export class GuardMaker {
             case OperatorType.TYPE_NUMBER_MULTIPLY:
             case OperatorType.TYPE_NUMBER_SUBTRACT:
             case OperatorType.TYPE_NUMBER_MOD:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length') }
-                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check')  }
-                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -2])) { ERROR(Errors.Fail, 'type_validator check')  }
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
+                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -2])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
                 ret = ValueType.TYPE_U256;
                 break;
             default:
-                ERROR(Errors.InvalidParam, 'add_logic type invalid' + type) 
+                ERROR(Errors.InvalidParam, 'add_logic type invalid:' + e) 
         }
-        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE     
+
+        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE 
+        if (type === OperatorType.TYPE_LOGIC_AND || type === OperatorType.TYPE_LOGIC_OR) {
+            this.data.push((Bcs.getInstance().ser(ValueType.TYPE_U8, param))); //@ logics
+        }    
         this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack   
         this.type_validator.push(ret); // add bool to type stack
         return this;
@@ -663,7 +683,7 @@ export class GuardMaker {
             maker.constant.set(k, {type:v.type, value:v.value, witness:v.witness});
         })
         let op = bAnd ? OperatorType.TYPE_LOGIC_AND :  OperatorType.TYPE_LOGIC_OR;
-        maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser(ValueType.TYPE_U8, op)));
+        maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser(ValueType.TYPE_U8, 2), Bcs.getInstance().ser(ValueType.TYPE_U8, op)));
         this.data.splice(0, this.data.length-1);
         maker.type_validator = this.type_validator;
         return maker
@@ -672,22 +692,17 @@ export class GuardMaker {
     get_constant() { return this.constant  }
     get_input() { return this.data }
 
+    // and/or + logics count
     static input_combine(input1:Uint8Array, input2:Uint8Array, bAnd:boolean = true) : Uint8Array {
         let op = bAnd ? OperatorType.TYPE_LOGIC_AND :  OperatorType.TYPE_LOGIC_OR;
-        return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser(ValueType.TYPE_U8, op)) as  Uint8Array;
+        return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser(ValueType.TYPE_U8, 2), Bcs.getInstance().ser(ValueType.TYPE_U8, op)) as  Uint8Array;
     }
     static input_not(input:Uint8Array) : Uint8Array {
         return concatenate(Uint8Array, input, Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_LOGIC_NOT)) as Uint8Array;
     }
 
     static match_u256(type:number) : boolean {
-        if (type == ValueType.TYPE_U8 || 
-            type == ValueType.TYPE_U64 || 
-            type == ValueType.TYPE_U128 ||
-            type == ValueType.TYPE_U256) {
-                return true;
-        }
-        return false;
+        return (type == ValueType.TYPE_U8 || type == ValueType.TYPE_U64 || type == ValueType.TYPE_U128 || type == ValueType.TYPE_U256);
     }
 }
 

package/src/passport.ts

@@ -71,12 +71,14 @@ export class GuardParser {
     static DeGuardObject_FromData = (guard_constants:any, guard_input_bytes:any) : {object:DeGuardData, constant:DeGuardConstant[]} => {
         let  constants : DeGuardConstant[] = [];
         guard_constants.forEach((c:any) => {
-            let value : any; 
             let v = c?.fields ?? c; // graphql dosnot 'fields', but rpcall has.
-            switch (v.type) {
+            const data:Uint8Array = Uint8Array.from(v.value);
+            const type = data.slice(0, 1)[0];
+            var value : any = data.slice(1);
+            switch (type) {
                 case ContextType.TYPE_WITNESS_ID:
                 case ValueType.TYPE_ADDRESS:
-                    value = '0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(v.value)).toString();
+                    value = '0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(value)).toString();
                     break;
                 case ValueType.TYPE_BOOL:
                 case ValueType.TYPE_U8:
@@ -100,15 +102,15 @@ export class GuardParser {
                 case ValueType.TYPE_OPTION_STRING:
                 case ValueType.TYPE_OPTION_VEC_U8:
                 case ValueType.TYPE_VEC_STRING:
-                    let de  = SER_VALUE.find(s=>s.type==v.type);
+                    let de  = SER_VALUE.find(s=>s.type==type);
                     if (!de) ERROR(Errors.Fail, 'GuardObject de error')
-                    value = Bcs.getInstance().de(de!.type as number, Uint8Array.from(v.value));
+                    value = Bcs.getInstance().de(type as number, Uint8Array.from(value));
                     break;
 
                 default:
-                    ERROR(Errors.Fail, 'GuardObject constant type invalid:' + v.type)
+                    ERROR(Errors.Fail, 'GuardObject constant type invalid:' +type)
             }
-            constants.push({identifier:v.identifier, type:v.type,  value:value});
+            constants.push({identifier:v.identifier, type:type,  value:value});
         });
         // console.log(constants)
         let bytes = Uint8Array.from(guard_input_bytes);
@@ -116,7 +118,7 @@ export class GuardParser {
         let data : DeGuardData[] = [];
         while (arr.length > 0) {
             let type : unknown = arr.shift() ;
-            let value:any; let cmd:any; let identifier:any;
+            let value:any; let cmd:any; let identifier:any; 
             switch (type as Data_Type) { 
                 case ContextType.TYPE_SIGNER:
                 case ContextType.TYPE_CLOCK:
@@ -129,18 +131,16 @@ export class GuardParser {
                 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:
-                case OperatorType.TYPE_LOGIC_AND3:
-                case OperatorType.TYPE_LOGIC_OR3:
-                case OperatorType.TYPE_LOGIC_AND4:
-                case OperatorType.TYPE_LOGIC_OR4:
                 case OperatorType.TYPE_NUMBER_ADD:
                 case OperatorType.TYPE_NUMBER_DEVIDE:
                 case OperatorType.TYPE_NUMBER_MOD:
                 case OperatorType.TYPE_NUMBER_MULTIPLY:
                 case OperatorType.TYPE_NUMBER_SUBTRACT:
                     break;    
+                case OperatorType.TYPE_LOGIC_AND: //@ with logics count
+                case OperatorType.TYPE_LOGIC_OR:
+                    value = arr.shift()! as number; 
+                    break;
                 case ContextType.TYPE_CONSTANT:
                     identifier = arr.shift()! as number;  // identifier
                     break;
@@ -348,7 +348,7 @@ export class GuardParser {
                 current.ret_type = ValueType.TYPE_BOOL;
                 if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
                 var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
-                console.log(p1); console.log(p2)
+                //console.log(p1); console.log(p2)
                 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');
 
@@ -361,7 +361,7 @@ export class GuardParser {
                 if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
                 var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
                 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) {
+                if (p1.ret_type != ValueType.TYPE_STRING || p2.ret_type != ValueType.TYPE_STRING) {
                     ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
                 }
 
@@ -372,15 +372,12 @@ export class GuardParser {
             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() as DeGuardData; var p2 = stack.pop() as DeGuardData;
-                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');
+                if (stack.length < current.value || current.value < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                for (let i = 0; i < current.value; ++i) {
+                    var p = stack.pop() as DeGuardData;
+                    if (!p.ret_type || (p.ret_type != ValueType.TYPE_BOOL))  ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                    current.child.push(p);
                 }
-
-                current.child.push(p1);
-                current.child.push(p2);
                 stack.push(current);
                 return
             case OperatorType.TYPE_QUERY:
@@ -543,12 +540,16 @@ export class GuardParser {
         constants.forEach((v:any) => {
             if (v.type == (Protocol.Instance().Package() + '::guard::Constant')) {
                 // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for querying
-                if (v.fields.type == ContextType.TYPE_WITNESS_ID || v.fields.type == ValueType.TYPE_ADDRESS) {
-                    info.constant.push({identifier:v.fields.identifier,  index:this.get_index(), type:v.fields.type,
-                        value_or_witness:'0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(v.fields.value))});
+                const data = Uint8Array.from(v.fields.value);
+                const type = data.slice(0, 1)[0];
+                const value = data.slice(1);
+                if (type == ContextType.TYPE_WITNESS_ID || type == ValueType.TYPE_ADDRESS) {
+                    info.constant.push({identifier:v.fields.identifier,  index:this.get_index(), type:type,
+                        value_or_witness:'0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(value))});
                 }
             }
         });
+        //console.log(info.constant)
     }
 
     parse_bcs = (info:GuardInfo, chain_bytes: Uint8Array) => {
@@ -568,14 +569,16 @@ export class GuardParser {
                 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:
                 case OperatorType.TYPE_NUMBER_ADD:
                 case OperatorType.TYPE_NUMBER_DEVIDE:
                 case OperatorType.TYPE_NUMBER_MOD:
                 case OperatorType.TYPE_NUMBER_MULTIPLY:
                 case OperatorType.TYPE_NUMBER_SUBTRACT:
                 break;    
+            case OperatorType.TYPE_LOGIC_AND: //@ logics count
+            case OperatorType.TYPE_LOGIC_OR:
+                arr.splice(0, 1); // identifier of constant
+                break;      
             case ContextType.TYPE_CONSTANT:
                 arr.splice(0, 1); // identifier of constant
                 break;
@@ -774,13 +777,13 @@ export class Passport {
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         // rules: 'verify' & 'query' in turns; 'verify' at final end.
         query?.query.forEach((q) => {
-            let address = this.txb.moveCall({
+            this.txb.moveCall({
                 target: Protocol.Instance().PassportFn('passport_verify') as FnCallType,
                 arguments: [ this.passport, this.txb.object(clock)]
             }); 
             this.txb.moveCall({
                 target: q.target as FnCallType,
-                arguments: [ bObject ? this.txb.object(q.object) : this.txb.object(q.id), this.passport, address ],
+                arguments: [ bObject ? this.txb.object(q.object) : this.txb.object(q.id), this.passport],
                 typeArguments: q.types,
             })
         })

package/src/protocol.ts

@@ -79,10 +79,6 @@ export enum OperatorType {
     TYPE_LOGIC_NOT = 19, // NOT
     TYPE_LOGIC_AND = 20, // AND
     TYPE_LOGIC_OR = 21, // OR
-    TYPE_LOGIC_AND3 = 22, // and
-    TYPE_LOGIC_AND4 = 23, // and
-    TYPE_LOGIC_OR3 = 24, // or
-    TYPE_LOGIC_OR4 = 25, // or
 }       
 
 export const LogicsInfo = [
@@ -91,16 +87,12 @@ export const LogicsInfo = [
     [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'Unsigned Integer <'],
     [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'Unsigned Integer <='],
     [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'Unsigned Integer ='],
-    [OperatorType.TYPE_LOGIC_EQUAL, 'Equals ='],
+    [OperatorType.TYPE_LOGIC_EQUAL, 'Equal'],
     [OperatorType.TYPE_LOGIC_HAS_SUBSTRING, 'Sub String'],
     [OperatorType.TYPE_LOGIC_ALWAYS_TRUE, 'Always True'], 
     [OperatorType.TYPE_LOGIC_NOT, 'Not'],
     [OperatorType.TYPE_LOGIC_AND, 'And'],
     [OperatorType.TYPE_LOGIC_OR, 'Or'], 
-    [OperatorType.TYPE_LOGIC_AND3, 'And 3'],
-    [OperatorType.TYPE_LOGIC_OR3, 'Or 3'], 
-    [OperatorType.TYPE_LOGIC_AND4, 'And 4'],
-    [OperatorType.TYPE_LOGIC_OR4, 'Or 4'], 
 ];
 
 export enum ValueType {
@@ -216,10 +208,10 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    package: "0x72a2ee21e11ee0c0d8fd9212127b12be0cdf7722b1e91c85a15a79cff3f7d9b0",
-    wowok_object: '0x3e69e10a8ab426c5e6d4392841bb6f6b9b45b7fa5feb9fcf23d7616a2effba0c',
-    entity_object: '0x53606d845cdedf0b256d27b3c0b0764265b2c272f3ad743a018ea4e8e59f3c74',
-    treasury_cap:'0xbbbc1fcab63e3373d53669507d7a6042282edef398273dcc04fe24db47c4881d',
+    package: "0x4ce36e03ef9cd230f1158e48293ee01cb572cdcd2f9cab7ac7b2fd2251bfe51e",
+    wowok_object: '0xd3639daf1daa300bbf694b21e42cecac6be242ad038fe48a7a1212e93f3845f6',
+    entity_object: '0x8de1e01e6baca0990ca18de3ec51b57183512deaeb76076be9161ca38988c74f',
+    treasury_cap:'0x2e05eda6ee5b0773854be6eb48c6cee2b5ca8aaa13ee810434d66232005b40ef',
 }
 const MAINNET = {
     package: "",

package/src/repository.ts

@@ -1,8 +1,8 @@
-import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
+import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject, } from './protocol';
 import { PermissionIndexType, Permission } from './permission'
 import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, IsValidName,  ValueTypeConvert} from './utils';
 import { ERROR, Errors } from './exception';
-import { MAX_U8, MAX_U128, MAX_U256, MAX_U64 } from './utils';
+import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, stringToUint8Array } from './utils';
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
 export enum Repository_Policy_Mode {

package/src/utils.ts

@@ -241,9 +241,10 @@ export class Bcs {
             case ValueType.TYPE_U256:
                 return this.bcs.ser(BCS.U256, data).toBytes();
             case ValueType.TYPE_STRING:
-                return this.bcs.ser(BCS.STRING, data).toBytes();
+                const d = new TextEncoder().encode(data);
+                return this.bcs.ser('vector<u8>', d).toBytes();
             case ValueType.TYPE_VEC_STRING:
-                return this.bcs.ser('vector<string>', data).toBytes();
+                return this.bcs.ser('vector<vector<u8>>', data.map((v:string)=>{return new TextEncoder().encode(v)})).toBytes();
             case ContextType.TYPE_WITNESS_ID:
                 return this.bcs.ser(BCS.ADDRESS, data).toBytes();
             default:
@@ -297,7 +298,8 @@ export class Bcs {
             case ValueType.TYPE_VEC_U256:
                 return this.bcs.de('vector<u256>', data);
             case ValueType.TYPE_STRING:
-                return this.bcs.de(BCS.STRING, data);
+                const r = new TextDecoder().decode(Uint8Array.from(this.bcs.de('vector<u8>', data)));
+                return r
             case ValueType.TYPE_VEC_STRING:
                 return this.bcs.de('vector<string>', data);
             case ValueType.TYPE_U256:
@@ -329,13 +331,10 @@ export class Bcs {
     }   
 }
 
-export function stringToUint8Array(str:string) : Uint8Array {
-    var arr = [];
-    for (var i = 0, j = str.length; i < j; ++i) {
-      arr.push(str.charCodeAt(i));
-    }
-    var tmpUint8Array = new Uint8Array(arr);
-    return tmpUint8Array
+export function stringToUint8Array(str:string) {
+    const encoder = new TextEncoder();
+    const view = encoder.encode(str);
+    return new Uint8Array(view.buffer);
 }
 
 export function numToUint8Array(num:number) : Uint8Array {
@@ -509,6 +508,15 @@ export const ParseType = (type:string) : ArgType => {
     return  {isCoin:false, coin:'', token:''}
 }
 
+
+export function insertAtHead(array:Uint8Array, value:number) {
+    const newLength = array.length + 1;
+    const newArray = new Uint8Array(newLength);
+    newArray.set([value], 0); 
+    newArray.set(array, 1);
+    return newArray;
+}
+
 export function toFixed(x:number) {
     let res = '';
     if (Math.abs(x) < 1.0) {