wowok 1.3.13 → 1.4.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.3.13",
+  "version": "1.4.18",
   "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

@@ -22,9 +22,10 @@ export enum Errors {
     isValidHttpUrl = 'invalid url',
     IsValidUserDefinedIndex = 'invalid user defined permission index',
     bcsTypeInvalid = 'invalid bcs type',
+    IsValidServiceItemName = 'invalid service item name',
 }
 
 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.'],
@@ -141,20 +150,24 @@ export class Guard {
         [MODULES.progress, 'Has Context Repository', 59, [], ValueType.TYPE_BOOL, 'Whether the repository reference for Progress is set?'],
         [MODULES.progress, 'Context Repository', 60, [], ValueType.TYPE_ADDRESS, 'Repository reference for Progress.'],   
         [MODULES.progress, 'Last Session Time', 61, [], ValueType.TYPE_U64, 'Time when the previous session was completed.'],
-        [MODULES.progress, 'Session Time', 62, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'Time a node completes its session.', 'Input:the node name'],  
-
-        [MODULES.demand, 'Permission', 71, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],       
-        [MODULES.demand, 'Has Deadline', 72, [], ValueType.TYPE_BOOL, 'Whether to set the expiration time of presenting?'],
-        [MODULES.demand, 'Deadline', 73, [], ValueType.TYPE_U64, 'The expiration time of presenting.'],   
-        [MODULES.demand, 'Bounty Count', 74, [], ValueType.TYPE_U64, 'Number of Bounties.'],   
-        [MODULES.demand, 'Has Guard', 75, [], ValueType.TYPE_BOOL, 'Whether the present guard is set?'],       
-        [MODULES.demand, 'Guard', 76, [], ValueType.TYPE_ADDRESS, 'The present guard address.'],
-        [MODULES.demand, 'Has Service Picked', 77, [], ValueType.TYPE_BOOL, 'Whether a service has been picked and bounties given?'],   
-        [MODULES.demand, 'Service Picked', 78, [], ValueType.TYPE_ADDRESS, 'Service address that has been picked.'], 
-        [MODULES.demand, 'Presenter Count', 79, [], ValueType.TYPE_U64, 'Number of presenters.'],
-        [MODULES.demand, 'Has Presenter', 80, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain address a presenter?', 'Input:address'],   
-        [MODULES.demand, 'Who Got Bounty', 81, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address that bounties given.', 'Input:address'], 
-    
+        [MODULES.progress, 'Last Session Node', 62, [], ValueType.TYPE_STRING, 'The name of the last completed node.'],  
+        [MODULES.progress, 'Current Session-id', 63, [], ValueType.TYPE_U64, 'The session id of ongoing node.'],  
+        [MODULES.progress, 'Parent Session-id', 64, [], ValueType.TYPE_U64, 'The child process was started in the Session-id phase of the parent process.'],   
+        [MODULES.progress, 'Parent Next Node', 65, [], ValueType.TYPE_STRING, 'The child process is started at the next node stage of the parent process.'],
+        [MODULES.progress, 'Parent Forward', 66, [], ValueType.TYPE_STRING, 'The child process is started in the Forward phase of the next node of the parent process.'],  
+        [MODULES.progress, 'Parent Node', 67, [], ValueType.TYPE_STRING, 'The node name of the parent process where the child process is located.'],  
+        [MODULES.progress, 'Forward Accomplished', 68, [ValueType.TYPE_U64, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Has a forward been accomplished?', 'Input 1:session-id; Input 2:next node name; Input 3:forward name'],  
+        [MODULES.progress, 'Forward Operator', 69, [ValueType.TYPE_U64, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The forward operator.', 'Input 1:session-id; Input 2:next node name; Input 3:forward name'],   
+        [MODULES.progress, 'Forward Sub-progress', 70, [ValueType.TYPE_U64, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The forward child process address(if set).', 'Input 1:session-id; Input 2:next node name; Input 3:forward name'],
+        [MODULES.progress, 'Forward Deliverables', 71, [ValueType.TYPE_U64, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The forward deliverable(if set).', 'Input 1:session-id; Input 2:next node name; Input 3:forward name'],  
+        [MODULES.progress, 'Forward time', 72, [ValueType.TYPE_U64, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The time when the forward was last triggered.', 'Input 1:session-id; Input 2:next node name; Input 3:forward name'],  
+        [MODULES.progress, 'Closest Session Time', 73, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The time a node that closest time to the current node completes its session.', 'Input:the node name'],  
+        [MODULES.progress, 'Closest Forward Accomplished', 74, [ValueType.TYPE_STRING, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Has a forward been accomplished?', 'Input 1:node name; Input 2:next node name; Input 3:forward name'],  
+        [MODULES.progress, 'Closest Forward Operator', 75, [ValueType.TYPE_STRING, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The operator of the forward that closest time to the current node.', 'Input 1:node name; Input 2:next node name; Input 3:forward name'],   
+        [MODULES.progress, 'Closest Forward Sub-progress', 76, [ValueType.TYPE_STRING, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The child process address(if set) of the forward that closest time to the current node.', 'Input 1:node name; Input 2:next node name; Input 3:forward name'],
+        [MODULES.progress, 'Closest Forward Deliverables', 77, [ValueType.TYPE_STRING, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The deliverable(if set) of the forward that closest time to the current node.', 'Input 1:node name; Input 2:next node name; Input 3:forward name'],  
+        [MODULES.progress, 'Closest Forward time', 78, [ValueType.TYPE_STRING, ValueType.TYPE_STRING, ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The time when the forward that closest time to the current node was last triggered.', 'Input 1:node name; Input 2:next node name; Input 3:forward name'],  
+
         [MODULES.order, 'Amount', 91, [], ValueType.TYPE_U64, 'Order amount.'],       
         [MODULES.order, 'Payer', 92, [], ValueType.TYPE_ADDRESS, 'Order payer.'],
         [MODULES.order, 'Service', 93, [], ValueType.TYPE_ADDRESS, 'Service for creating orders.'],   
@@ -187,6 +200,18 @@ export class Guard {
         [MODULES.service, 'Required Info of Service-Pubkey', 128, [], ValueType.TYPE_STRING, 'The public key used to encrypt customer information, and only the service provider can decrypt and view customer information.'],   
         [MODULES.service, 'Required Info', 129, [], ValueType.TYPE_VEC_STRING, 'Names of the required information item that needs to be provided by the customer.'],  
     
+        [MODULES.demand, 'Permission', 135, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],       
+        [MODULES.demand, 'Has Deadline', 136, [], ValueType.TYPE_BOOL, 'Whether to set the expiration time of presenting?'],
+        [MODULES.demand, 'Deadline', 137, [], ValueType.TYPE_U64, 'The expiration time of presenting.'],   
+        [MODULES.demand, 'Bounty Count', 138, [], ValueType.TYPE_U64, 'Number of Bounties.'],   
+        [MODULES.demand, 'Has Guard', 139, [], ValueType.TYPE_BOOL, 'Whether the present guard is set?'],       
+        [MODULES.demand, 'Guard', 140, [], ValueType.TYPE_ADDRESS, 'The present guard address.'],
+        [MODULES.demand, 'Has Service Picked', 141, [], ValueType.TYPE_BOOL, 'Whether a service has been picked and bounties given?'],   
+        [MODULES.demand, 'Service Picked', 142, [], ValueType.TYPE_ADDRESS, 'Service address that has been picked.'], 
+        [MODULES.demand, 'Presenter Count', 143, [], ValueType.TYPE_U64, 'Number of presenters.'],
+        [MODULES.demand, 'Has Presenter', 144, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain address a presenter?', 'Input:address'],   
+        [MODULES.demand, 'Who Got Bounty', 145, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address that bounties given.', 'Input:address'], 
+    
         [MODULES.reward, 'Permission', 151, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],       
         [MODULES.reward, 'Rewards Remaining', 152, [], ValueType.TYPE_U64, 'Number of rewards to be claimed.'],
         [MODULES.reward, 'Reward Count Supplied', 153, [], ValueType.TYPE_U64, 'Total rewards supplied.'],   
@@ -295,7 +320,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 +387,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 +416,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 +450,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 +460,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 +470,7 @@ 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 +494,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 +512,60 @@ 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:
+        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');
-            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));
+            if (!v) ERROR(Errors.Fail, 'identifier not in constant:'+e);
+            var t = v!.type; 
+            if (v?.type === ContextType.TYPE_WITNESS_ID) {
+                t = ValueType.TYPE_ADDRESS;
+            }
+            this.type_validator.push(t); //@ type validator convert
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // constant flag
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, param)); // identifier
             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 +575,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 +590,10 @@ export class GuardMaker {
         return this;
     }
 
-    add_logic(type:OperatorType) : GuardMaker {
+    add_logic(type:OperatorType, logic_count: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 +602,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 (!logic_count || logic_count < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = logic_count!;
+                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 +645,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, logic_count))); //@ 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 +702,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, op), Bcs.getInstance().ser(ValueType.TYPE_U8, 2)));
         this.data.splice(0, this.data.length-1);
         maker.type_validator = this.type_validator;
         return maker
@@ -672,22 +711,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, op), Bcs.getInstance().ser(ValueType.TYPE_U8, 2), ) 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;
@@ -762,6 +765,7 @@ export class Passport {
             });        
         })
 
+        console.log(query)
         // witness
         query?.witness.forEach((w) => {
             this.txb.moveCall({
@@ -774,13 +778,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/permission.ts

@@ -273,7 +273,7 @@ export class  Permission {
             ERROR(Errors.IsValidArray, 'add_entity2');
         }
 
-        if (index) {
+        if (index !== undefined) {
             this.txb.moveCall({
                 target:Protocol.Instance().PermissionFn('add_with_index') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(index),
@@ -288,9 +288,7 @@ export class  Permission {
     }
 
     add_entity(entities:Permission_Entity[])  {
-        if (!entities) {
-            ERROR(Errors.InvalidParam, 'add_entity');
-        }
+        if (entities.length === 0) return
 
         let bValid = true;
         let e = entities.forEach((v) => {
@@ -322,13 +320,14 @@ export class  Permission {
                     }
                 }      
             }    
-            //if (indexes.length > 0) {
+
+            if (indexes.length > 0) {
                 this.txb.moveCall({
                     target:Protocol.Instance().PermissionFn('add_batch') as FnCallType,
                     arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity.entity_address), 
                         this.txb.pure.vector('u64', indexes)]
                 })            
-            //}
+            }
         } 
         // set guards
         guards.forEach(({entity_address, index, guard}) => {
@@ -368,7 +367,8 @@ export class  Permission {
         if (!IsValidAddress(entity_address)) {
             ERROR(Errors.IsValidAddress)
         }
-        if (!index || !(IsValidArray(index, Permission.IsValidPermissionIndex))) {
+        if (index.length === 0) return ;
+        if (!(IsValidArray(index, Permission.IsValidPermissionIndex))) {
             ERROR(Errors.InvalidParam, 'index')
         }
 
@@ -379,7 +379,8 @@ export class  Permission {
         })            
     }
     remove_entity(entity_address:string[])  {
-        if (!entity_address || !IsValidArray(entity_address, IsValidAddress)) {
+        if (entity_address.length === 0) return ;
+        if (!IsValidArray(entity_address, IsValidAddress)) {
             ERROR(Errors.IsValidArray)
         }
 

package/src/progress.ts

@@ -188,24 +188,25 @@ export class Progress {
         }
     }
     unhold(next:ProgressNext, passport?:PassportObject)  {
-        console.log(next)
         if (!Progress.IsValidProgressNext(next)) {
             ERROR(Errors.InvalidParam, 'unhold')
         }
         
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().ProgressFn('unhold_with_passport') as FnCallType,
                 arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), 
                     Protocol.TXB_OBJECT(this.txb, this.machine), this.txb.pure.string(next.next_node_name), 
-                    this.txb.pure.string(next.forward), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.pure.string(next.forward), Protocol.TXB_OBJECT(this.txb, this.permission), this.txb.object(clock)],
             })     
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().ProgressFn('unhold') as FnCallType,
                 arguments: [Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.machine), 
                     this.txb.pure.string(next.next_node_name), this.txb.pure.string(next.forward), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    Protocol.TXB_OBJECT(this.txb, this.permission), this.txb.object(clock)],
             })           
         }
     }
@@ -293,11 +294,11 @@ export class Progress {
         if (!Progress.IsValidProgressNext(next)) {
             ERROR(Errors.InvalidParam, 'hold')
         }
-        
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         this.txb.moveCall({
             target:Protocol.Instance().ProgressFn('hold') as FnCallType,
             arguments: [Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.machine), this.txb.pure.string(next.next_node_name), 
-                this.txb.pure.string(next.forward), this.txb.pure.bool(hold), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                this.txb.pure.string(next.forward), this.txb.pure.bool(hold), Protocol.TXB_OBJECT(this.txb, this.permission), this.txb.object(clock)],
         })  
     }
 

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 {
@@ -173,7 +165,7 @@ interface ValueTypeString {
 export const SER_VALUE: ValueTypeString[] = [
     {type: ValueType.TYPE_BOOL, name: 'bool', description:'boolean. eg:true or false', validator:(value:any) => { return (value === true || value === false)}},
     {type: ValueType.TYPE_ADDRESS, name: 'address', description:'address or object-id. eg:0x6789af', validator:IsValidAddress},
-    {type: ContextType.TYPE_WITNESS_ID, name: 'future address', description:"eg: address of the Machine that will generate future Progress, address of the Service that will generate future Order",  validator:IsValidAddress},
+    {type: ContextType.TYPE_WITNESS_ID, name: 'witness address', description:"For example, the address of the Machine object ensures that the Progress generated in the past or future is verified; the address of the Service object ensures that the Order generated in the past or future is verified.",  validator:IsValidAddress},
     {type: ContextType.TYPE_SIGNER, name: 'txn signer', description:"signer address of the transaction, "},
     {type: ContextType.TYPE_CLOCK, name: 'txn time', description:"unsigned-64 number for the transaction time"},
     {type: ValueType.TYPE_U64, name: 'number', description:'unsigned-64 number. eg:23870233', validator:IsValidU64},
@@ -216,10 +208,10 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    package: "0x72a2ee21e11ee0c0d8fd9212127b12be0cdf7722b1e91c85a15a79cff3f7d9b0",
-    wowok_object: '0x3e69e10a8ab426c5e6d4392841bb6f6b9b45b7fa5feb9fcf23d7616a2effba0c',
-    entity_object: '0x53606d845cdedf0b256d27b3c0b0764265b2c272f3ad743a018ea4e8e59f3c74',
-    treasury_cap:'0xbbbc1fcab63e3373d53669507d7a6042282edef398273dcc04fe24db47c4881d',
+    package: "0x7a36d0cb4ac23770bd07b770997b5ceef57e8f7b22563eea945111a0bcf38e8d",
+    wowok_object: '0xa79bbf5d1b96a015da7b763bc9528a226c8dbf86e481947aa5cfd0d3949da33b',
+    entity_object: '0x524dcfb8d2fad580ccffb09cc3b3b1377213db040dad6cdad36ed5a99f1b0c00',
+    treasury_cap:'0x8e4dbb61e5cd2ca4812faa86e0e1d886903bd0c48c8bf8d5af0856cb8a8e5df1',
 }
 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/service.ts

@@ -1,5 +1,5 @@
 import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, Bcs, array_unique, IsValidTokenType, IsValidDesription, 
-    IsValidAddress, IsValidEndpoint, IsValidU64, IsValidName,} from './utils'
+    IsValidAddress, IsValidEndpoint, IsValidU64, } from './utils'
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryObject, MachineObject, ServiceAddress, 
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
     TxbObject} from './protocol';
@@ -155,10 +155,11 @@ export class Service {
     }
     set_price(item:string, price:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject) {
         if (!IsValidU64(price)) {
-            ERROR(Errors.IsValidU64, 'price')
+            ERROR(Errors.IsValidU64, 'set_price price')
         } 
-        if (!IsValidName(item)) {
-            ERROR(Errors.IsValidName, 'item')
+
+        if (!Service.IsValidItemName(item)) {
+            ERROR(Errors.IsValidServiceItemName, 'set_price item')
         }
         
         if (passport) {
@@ -180,8 +181,8 @@ export class Service {
         }
     }
     set_stock(item:string, stock:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
-        if (!IsValidName(item)) {
-            ERROR(Errors.IsValidName, 'item')
+        if (!Service.IsValidItemName(item)) {
+            ERROR(Errors.IsValidServiceItemName, 'item')
         }
         if (!IsValidU64(stock)) {
             ERROR(Errors.IsValidU64, 'stock')
@@ -206,11 +207,11 @@ export class Service {
         }
     }
     add_stock(item:string, stock_add:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
-        if (!IsValidName(item)) {
-            ERROR(Errors.IsValidName, 'item')
+        if (!Service.IsValidItemName(item)) {
+            ERROR(Errors.IsValidServiceItemName, 'add_stock item')
         }
         if (!IsValidU64(stock_add)) {
-            ERROR(Errors.IsValidUint, 'stock_add')
+            ERROR(Errors.IsValidUint, 'add_stock stock_add')
         }
         
         if (passport) {
@@ -232,11 +233,11 @@ export class Service {
         }
     }
     reduce_stock(item:string, stock_reduce:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
-        if (!IsValidName(item)) {
-            ERROR(Errors.IsValidName, 'item')
+        if (!Service.IsValidItemName(item)) {
+            ERROR(Errors.IsValidServiceItemName, 'reduce_stock item')
         }
         if (!IsValidU64(stock_reduce)) {
-            ERROR(Errors.IsValidUint, 'stock_reduce')
+            ERROR(Errors.IsValidUint, 'reduce_stock stock_reduce')
         }
 
         if (passport) {
@@ -259,11 +260,11 @@ export class Service {
     }
 
     set_sale_endpoint(item:string, endpoint?:string|null, bNotFoundAssert:boolean=true, passport?:PassportObject) {
-        if (!IsValidName(item)) {
-            ERROR(Errors.IsValidName, 'set_sale_endpoint')
+        if (!Service.IsValidItemName(item)) {
+            ERROR(Errors.IsValidServiceItemName, 'set_sale_endpoint item')
         }
         if (endpoint && !IsValidEndpoint(endpoint)) {
-            ERROR(Errors.IsValidEndpoint, 'set_sale_endpoint')
+            ERROR(Errors.IsValidEndpoint, 'set_sale_endpoint endpoint')
         }
         
         let ep =  this.txb.pure.option('string', endpoint ? endpoint : undefined);
@@ -505,7 +506,7 @@ export class Service {
     is_valid_sale(sales:Service_Sale[]) {
         let bValid = true; let names:string[]  = [];
         sales.forEach((v) => {
-            if (!IsValidName(v.item)) bValid = false;
+            if (!Service.IsValidItemName(v.item)) bValid = false;
             if (!IsValidU64(v.price)) bValid = false;
             if (!IsValidU64(v.stock)) bValid = false;
             if (names.includes(v.item)) bValid = false;
@@ -555,7 +556,7 @@ export class Service {
     remove_sales(sales:string[], passport?:PassportObject) {
         if (sales.length === 0) return;
 
-        if (!IsValidArray(sales, IsValidName)) {
+        if (!IsValidArray(sales, Service.IsValidItemName)) {
             ERROR(Errors.IsValidArray, 'remove_sales')
         }
         
@@ -913,7 +914,7 @@ export class Service {
 
         let bValid = true; let names:string[]  = [];
         buy_items.forEach((v) => {
-            if (!IsValidName(v.item)) bValid = false;
+            if (!Service.IsValidItemName(v.item)) bValid = false;
             if (!IsValidU64(v.max_price)) bValid = false;
             if (!IsValidU64(v.count)) bValid = false;
             if (names.includes(v.item)) bValid = false;
@@ -1010,8 +1011,14 @@ export class Service {
     static MAX_DISCOUNT_COUNT_ONCE = 200;
     static MAX_DISCOUNT_RECEIVER_COUNT = 20;
     static MAX_GUARD_COUNT = 16;
-    static MAX_REPOSITORY_COUNT = 16;
-    
+    static MAX_REPOSITORY_COUNT = 32;
+    static MAX_ITEM_NAME_LENGTH = 256;
+     
+    static IsValidItemName(name:string) : boolean {
+        if (!name) return false;
+        return new TextEncoder().encode(name).length <= Service.MAX_ITEM_NAME_LENGTH;
+    }
+
     static parseObjectType = (chain_type:string | undefined | null) : string =>  {
         if (chain_type) {
             const s = 'service::Service<'

package/src/utils.ts

@@ -120,7 +120,6 @@ export const concatenate = (resultConstructor:any, ...arrays:any[]) => {
 }
 
 export const array_equal =  (arr1: any[], arr2: any[]) => {
-    // Array.some(): 有一项不满足，返回false
     if (arr1.length !== arr2.length) {
       return false;
     }
@@ -241,9 +240,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 +297,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 +330,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 +507,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) {