wowok 1.3.10 → 1.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.3.10",
+  "version": "1.3.13",
   "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/guard.ts

@@ -6,9 +6,9 @@ import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercas
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
-export type GuardConstant = Map<number, Guard_Vriable>;
+export type GuardConstant = Map<number, Guard_Variable>;
 
-export interface Guard_Vriable {
+export interface Guard_Variable {
     type: ConstantType ,
     value?: Uint8Array,
     witness?: Uint8Array,
@@ -22,7 +22,7 @@ export  interface Guard_Options {
 }
 
 export class Guard {
-    static MAX_INPUT_LENGTH = 2048;
+    static MAX_INPUT_LENGTH = 10240;
     static launch(txb:TransactionBlock, description:string, maker:GuardMaker) : GuardAddress  {
         if (!maker.IsReady()) {
             ERROR(Errors.InvalidParam, 'launch maker');
@@ -98,109 +98,111 @@ export class Guard {
 
     static QUERIES:any[] = [ 
         // module, 'name', 'id', [input], output
-        [MODULES.permission, 'Builder', 1, [], ValueType.TYPE_ADDRESS],
-        [MODULES.permission, 'Has Admin', 2, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
-        [MODULES.permission, 'Has Rights', 3, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
-        [MODULES.permission, 'Contains Address', 4, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
-        [MODULES.permission, 'Contains Index of Address', 5, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
-        [MODULES.permission, 'Contains Guard of Address', 6, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL],
-        [MODULES.permission, 'Guard of Address', 7, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_ADDRESS],
-        [MODULES.permission, 'Entity Count', 8, [], ValueType.TYPE_U64],
-        [MODULES.permission, 'Admin Count', 9, [], ValueType.TYPE_U64],
+        [MODULES.permission, 'Owner', 1, [], ValueType.TYPE_ADDRESS, "Owner's address."],
+        [MODULES.permission, 'Is Admin', 2, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain address an administrator?', 'Input:address'],
+        [MODULES.permission, 'Has Rights', 3, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Does an address have a certain permission(Admin always have permissions)?', 'Input 1:address; Input 2:permission index'],
+        [MODULES.permission, 'Contains Address', 4, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is included in the personnel permission table?', 'Input:address'],
+        [MODULES.permission, 'Contains Permission', 5, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Whether a certain permission for a certain address is defined in the personnel permission table?', 'Input 1:address; Input 2:permission index'],
+        [MODULES.permission, 'Contains Permission Guard', 6, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_BOOL, 'Whether a permission guard for a certain address is defined in the personnel permission table?', 'Input 1:address; Input 2:permission index'],
+        [MODULES.permission, 'Permission Guard', 7, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U64], ValueType.TYPE_ADDRESS, 'Permission guard for a certain address.', 'Input 1:address; Input 2:permission index'],
+        [MODULES.permission, 'Number of Entities', 8, [], ValueType.TYPE_U64, 'Number of entities in the personnel permission table.'],
+        [MODULES.permission, 'Number of Admin', 9, [], ValueType.TYPE_U64, 'Number of administrators.'],
     
-        [MODULES.repository, 'Permission', 11, [], ValueType.TYPE_ADDRESS],
-        [MODULES.repository, 'Contains Policy', 12, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
-        [MODULES.repository, 'Has Permission of Policy', 13, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
-        [MODULES.repository, 'Permission of Policy', 14, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
-        [MODULES.repository, 'Value Type of Policy',  15, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U8],
-        [MODULES.repository, 'Contains Id', 16, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],   
-        [MODULES.repository, 'Contains Value', 17, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
-        [MODULES.repository, 'Value without Type', 18, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_VEC_U8],       
-        [MODULES.repository, 'Value', 19, [ValueType.TYPE_ADDRESS, ValueType.TYPE_VEC_U8], ValueType.TYPE_VEC_U8],
-        [MODULES.repository, 'Type', 20, [], ValueType.TYPE_U8],   
-        [MODULES.repository, 'Policy Mode', 21, [], ValueType.TYPE_U8],   
-        [MODULES.repository, 'Reference Count', 22, [], ValueType.TYPE_U64],   
-        [MODULES.repository, 'Has Reference', 23, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],   
-
-        [MODULES.machine, 'Permission', 31, [], ValueType.TYPE_ADDRESS],
-        [MODULES.machine, 'Paused', 32, [], ValueType.TYPE_BOOL],
-        [MODULES.machine, 'Published', 33, [], ValueType.TYPE_BOOL],
-        [MODULES.machine, 'Is Consensus Repository', 34, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
-        [MODULES.machine, 'Has Endpoint', 35, [], ValueType.TYPE_BOOL],   
-        [MODULES.machine, 'Endpoint', 36, [], ValueType.TYPE_VEC_U8],
+        [MODULES.repository, 'Permission', 11, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],
+        [MODULES.repository, 'Contains Policy', 12, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Is a consensus policy included?', 'Input:the filed name'],
+        [MODULES.repository, 'Is Permission set of Policy', 13, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does a certain consensus policy set data operation permissions?', 'Input:the policy name'],
+        [MODULES.repository, 'Permission of Policy', 14, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The permission index of a certain consensus policy in the Permission object.', 'Input:the policy name'],
+        [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, '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'],   
+        // , 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.progress, 'Machine', 51, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.progress, 'Current Node', 52, [], ValueType.TYPE_VEC_U8],
-        [MODULES.progress, 'Has Parent', 53, [], ValueType.TYPE_BOOL],   
-        [MODULES.progress, 'Parent', 54, [], ValueType.TYPE_ADDRESS],   
-        [MODULES.progress, 'Has Task', 55, [], ValueType.TYPE_BOOL],       
-        [MODULES.progress, 'Task', 56, [], ValueType.TYPE_ADDRESS],
-        [MODULES.progress, 'Has Operator', 57, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],   
-        [MODULES.progress, 'Is Operator for Address', 58, [ValueType.TYPE_VEC_U8, ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.progress, 'Has Context Repository', 59, [], ValueType.TYPE_BOOL],
-        [MODULES.progress, 'Context Repository', 60, [], ValueType.TYPE_ADDRESS],   
+        [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.'],
+        [MODULES.progress, 'Has Parent', 53, [], ValueType.TYPE_BOOL, 'Is the parent Progress defined?'],   
+        [MODULES.progress, 'Parent', 54, [], ValueType.TYPE_ADDRESS, 'The parent Progress, that contains some child Progress.'],   
+        [MODULES.progress, 'Has Task', 55, [], ValueType.TYPE_BOOL, 'Does it contain clear task(eg. an Order)?'],       
+        [MODULES.progress, 'Task', 56, [], ValueType.TYPE_ADDRESS, 'Task object address.'],
+        [MODULES.progress, 'Has Unique Permission', 57, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Does Progress define a unique operation permission?', 'Input:opertor name'],   
+        [MODULES.progress, 'Is Unique Permission Operator', 58, [ValueType.TYPE_STRING, ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is an address an operator with unique permissions?', 'Input 1:operator name; Input 2:address'], 
+        [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.demand, 'Permission', 71, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.demand, 'Has Deadline', 72, [], ValueType.TYPE_BOOL],
-        [MODULES.demand, 'Deadline', 73, [], ValueType.TYPE_U64],   
-        [MODULES.demand, 'Bounty Count', 74, [], ValueType.TYPE_U64],   
-        [MODULES.demand, 'Has Guard', 75, [], ValueType.TYPE_BOOL],       
-        [MODULES.demand, 'Guard', 76, [], ValueType.TYPE_ADDRESS],
-        [MODULES.demand, 'Has Service Picked', 77, [], ValueType.TYPE_BOOL],   
-        [MODULES.demand, 'Service Picked', 78, [], ValueType.TYPE_ADDRESS], 
-        [MODULES.demand, 'Presenter Count', 79, [], ValueType.TYPE_U64],
-        [MODULES.demand, 'Is Presenter', 80, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],   
-        [MODULES.demand, 'Who Got Bounty', 81, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS], 
+        [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.'],   
+        [MODULES.order, 'Has Progress', 94, [], ValueType.TYPE_BOOL, 'Is there a Progress for executing the order process?'],   
+        [MODULES.order, 'Progress', 95, [], ValueType.TYPE_ADDRESS, 'Progress address for executing the order process.'],       
+        [MODULES.order, 'Required Info Counts', 96, [], ValueType.TYPE_U64, 'How much customer information is required for this order?'],
+        [MODULES.order, 'Discount Used', 97, [], ValueType.TYPE_BOOL, 'Discount coupon used for this order?'],   
+        [MODULES.order, 'Discount', 98, [], ValueType.TYPE_ADDRESS, 'Discount address that already used.'], 
+        [MODULES.order, 'Balance', 99, [], ValueType.TYPE_U64, 'The amount currently in the order.'], 
+        [MODULES.order, 'Refunded', 100, [], ValueType.TYPE_BOOL, 'Whether a refund has occurred?'],
+        [MODULES.order, 'Withdrawed', 101, [], ValueType.TYPE_BOOL, 'Whether a service provider withdrawal has occurred?'],   
     
-        [MODULES.order, 'Amount', 91, [], ValueType.TYPE_U64],       
-        [MODULES.order, 'Payer', 92, [], ValueType.TYPE_ADDRESS],
-        [MODULES.order, 'Service', 93, [], ValueType.TYPE_ADDRESS],   
-        [MODULES.order, 'Has Progress', 94, [], ValueType.TYPE_BOOL],   
-        [MODULES.order, 'Progress', 95, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.order, 'Required Info Counts', 96, [], ValueType.TYPE_U64],
-        [MODULES.order, 'Discount Used', 97, [], ValueType.TYPE_BOOL],   
-        [MODULES.order, 'Discount', 98, [], ValueType.TYPE_ADDRESS], 
-        [MODULES.order, 'Balance', 99, [], ValueType.TYPE_U64], 
-        [MODULES.order, 'Be Refunded', 100, [], ValueType.TYPE_BOOL],
-        [MODULES.order, 'Be Withdrawed', 101, [], ValueType.TYPE_BOOL],   
+        [MODULES.service, 'Permission', 111, [], ValueType.TYPE_ADDRESS, 'Permission object address.'],       
+        [MODULES.service, 'Payee', 112, [], ValueType.TYPE_ADDRESS, 'Payee address, that all order withdrawals will be collected to this address.'],
+        [MODULES.service, 'Has Buying Guard', 113, [], ValueType.TYPE_BOOL, 'Is the guard condition of buying set?'],   
+        [MODULES.service, 'Buying Guard', 114, [], ValueType.TYPE_ADDRESS, 'Buying guard, that Purchase only if you meet the conditions of the guard.'],   
+        [MODULES.service, 'Contains Repository', 115, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, "Is a certain repository one of the service's consensus repositories?", 'Input:address'],       
+        [MODULES.service, 'Has Withdrawing Guard', 116, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain guard is set when withdrawing money?', 'Input:address'],
+        [MODULES.service, 'Withdrawing Guard Percent', 117, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The percentage of withdrawals allowed by a certain withdrawal guard.', 'Input:address'],   
+        [MODULES.service, 'Has Refunding Guard', 118, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain guard is set when refunding money?', 'Input:address'], 
+        [MODULES.service, 'Refunding Guard Percent', 119, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The percentage of refund allowed by a certain refund guard.', 'Input:address'],
+        [MODULES.service, 'Has Sales Item', 120, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Is there a sales item for the service?', 'Input:the item name'],   
+        [MODULES.service, 'Sale Item Price', 121, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'What is the price of a certain sale item?', 'Input:the item name'], 
+        [MODULES.service, 'Sale Item Inventory', 122, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'How much inventory is there for a certain sales item?', 'Input:the item name'], 
+        [MODULES.service, 'Has Machine', 123, [], ValueType.TYPE_BOOL, "Has the machine(progress generator) that serves the order been set up?"],
+        [MODULES.service, 'Machine', 124, [], ValueType.TYPE_ADDRESS, 'Machine address, that generate progresses serving the execution process of order.'],  
+        [MODULES.service, 'Paused', 125, [], ValueType.TYPE_BOOL, 'Pause the creation of new order?'], 
+        [MODULES.service, 'Published', 126, [], ValueType.TYPE_BOOL, 'Is it allowed to create orders?'], 
+        [MODULES.service, 'Has Required Info', 127, [], ValueType.TYPE_BOOL, 'Whether the necessary information that needs to be provided by the customer is set?'],
+        [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.service, 'Permission', 111, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.service, 'Payee', 112, [], ValueType.TYPE_ADDRESS],
-        [MODULES.service, 'Has Buy-Guard', 113, [], ValueType.TYPE_BOOL],   
-        [MODULES.service, 'Buy-Guard', 114, [], ValueType.TYPE_ADDRESS],   
-        [MODULES.service, 'Contains Repository', 115, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],       
-        [MODULES.service, 'Has Withdraw-Guard', 116, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
-        [MODULES.service, 'Withdraw-Guard Percent', 117, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],   
-        [MODULES.service, 'Has Refund-Guard', 118, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.service, 'Refund-Guard Percent', 119, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
-        [MODULES.service, 'Has Sale Item', 120, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],   
-        [MODULES.service, 'Sale Item Price', 121, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64], 
-        [MODULES.service, 'Sale Item Inventory', 122, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64], 
-        [MODULES.service, 'Has Machine', 123, [], ValueType.TYPE_BOOL],
-        [MODULES.service, 'Machine', 124, [], ValueType.TYPE_ADDRESS],   
-        [MODULES.service, 'Paused', 125, [], ValueType.TYPE_BOOL], 
-        [MODULES.service, 'Published', 126, [], ValueType.TYPE_BOOL], 
-        [MODULES.service, 'Has Required Info', 127, [], ValueType.TYPE_BOOL],
-        [MODULES.service, 'Required Info of Service-Pubkey', 128, [], ValueType.TYPE_VEC_U8],   
-        [MODULES.service, 'Required Info', 129, [], ValueType.TYPE_VEC_VEC_U8],  
+        [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.'],   
+        [MODULES.reward, 'Guard Count', 154, [], ValueType.TYPE_U64, 'The number of claiming guards.'],   
+        [MODULES.reward, 'Has Guard', 155, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a claiming guard is set up?', 'Input:address'],       
+        [MODULES.reward, 'Guard Portion', 156, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of rewards, that can be claimed if a certain guard condition is met.', 'Input:address'],
+        [MODULES.reward, 'Deadline', 157, [], ValueType.TYPE_U64, 'The expiration time of claiming.'],   
+        [MODULES.reward, 'Has Claimed by An Address', 158, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether a certain address has claimed rewards?', 'Input:address'], 
+        [MODULES.reward, 'Portions Claimed by An Address', 159, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of rewards that have been claimed by a certain address.'],
+        [MODULES.reward, 'Number of Addresses Claimed', 160, [], ValueType.TYPE_U64, 'Number of addresses that have claimed rewards.'],   
+        [MODULES.reward, 'Is Sponsor', 161, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is a sponsor of the reward pool?', 'Input:address'], 
+        [MODULES.reward, 'Portions by A Sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of sponsorship reward pools for a certain address.', 'Input:address'], 
+        [MODULES.reward, 'Number of Sponsors', 163, [], ValueType.TYPE_U64, 'Number of sponsors in the sponsorship reward pool.'],
+        [MODULES.reward, 'Allow Repeated Claims', 164, [], ValueType.TYPE_BOOL, 'Whether to allow repeated claims?'],  
     
-        [MODULES.reward, 'Permission', 151, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.reward, 'Reward Count Left', 152, [], ValueType.TYPE_U64],
-        [MODULES.reward, 'Reward Count Supplied', 153, [], ValueType.TYPE_U64],   
-        [MODULES.reward, 'Guard Count', 154, [], ValueType.TYPE_U64],   
-        [MODULES.reward, 'Has Guard', 155, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],       
-        [MODULES.reward, 'Guard Portion', 156, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
-        [MODULES.reward, 'Deadline', 157, [], ValueType.TYPE_U64],   
-        [MODULES.reward, 'Has Claimed by Address', 158, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.reward, 'Claimed by Address', 159, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],
-        [MODULES.reward, 'Address Count Claimed', 160, [], ValueType.TYPE_U64],   
-        [MODULES.reward, 'Is Sponsor', 161, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.reward, 'Portion by Sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.reward, 'Sponsor Count', 163, [], ValueType.TYPE_U64],
-        [MODULES.reward, 'Allow Repeat Claim', 164, [], ValueType.TYPE_BOOL],  
-        [MODULES.reward, 'Claimed Portion by Address', 165, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],  
-    
-        [MODULES.vote, 'Permission', 171, [], ValueType.TYPE_ADDRESS],       
+/*        [MODULES.vote, 'Permission', 171, [], ValueType.TYPE_ADDRESS],       
         [MODULES.vote, 'Options Locked', 172, [], ValueType.TYPE_BOOL],
         [MODULES.vote, 'Deadline Locked', 173, [], ValueType.TYPE_BOOL],   
         [MODULES.vote, 'Vote-Guard Locked', 174, [], ValueType.TYPE_BOOL],   
@@ -212,33 +214,33 @@ export class Guard {
         [MODULES.vote, 'Vote-Guard', 180, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],   
         [MODULES.vote, 'Has Voted by Address', 181, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
         [MODULES.vote, 'Voted Weight by Address', 182, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Has Option', 183, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],
-        [MODULES.vote, 'Has Object of Option', 184, [ValueType.TYPE_VEC_U8], ValueType.TYPE_BOOL],   
-        [MODULES.vote, 'Option Object', 185, [ValueType.TYPE_VEC_U8], ValueType.TYPE_ADDRESS], 
-        [MODULES.vote, 'Option Count', 186, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Option Votes', 187, [ValueType.TYPE_VEC_U8], ValueType.TYPE_U64],
+        [MODULES.vote, 'Has Option', 183, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
+        [MODULES.vote, 'Has Object of Option', 184, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],   
+        [MODULES.vote, 'Option Object', 185, [ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS], 
+        [MODULES.vote, 'Option Count', 186, [ValueType.TYPE_STRING], ValueType.TYPE_U64], 
+        [MODULES.vote, 'Option Votes', 187, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
         [MODULES.vote, 'Address Count Voted', 188, [], ValueType.TYPE_U64],   
-        [MODULES.vote, 'Top1 Option by Addresses', 189, [], ValueType.TYPE_VEC_U8], 
+        [MODULES.vote, 'Top1 Option by Addresses', 189, [], ValueType.TYPE_STRING], 
         [MODULES.vote, 'Top1 Count by Addresses', 190, [], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Top1 Option by Votes', 191, [], ValueType.TYPE_VEC_U8], 
-        [MODULES.vote, 'Top1 Count by Votes', 192, [], ValueType.TYPE_U64], 
-
-        [MODULES.wowok, 'Builder', 210, [], ValueType.TYPE_ADDRESS], 
-        [MODULES.wowok, 'Everyone-Guard', 211, [], ValueType.TYPE_ADDRESS], 
-        [MODULES.wowok, 'Object of Entities', 212, [], ValueType.TYPE_ADDRESS],
-        [MODULES.wowok, 'Grantor Count', 213, [], ValueType.TYPE_U64],   
-        [MODULES.wowok, 'Has Grantor', 214, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.wowok, 'Grantor Name', 215, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8], 
-        [MODULES.wowok, 'Grantor Registration Time', 216, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.wowok, 'Grantor Expired Time', 217, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.wowok, 'Grantee Object for Grantor', 218, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS], 
-
-        [MODULES.entity, 'Has Entity', 230, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.entity, 'Likes', 231, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.entity, 'Dislikes', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.entity, 'Entity Info', 233, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8], 
-        [MODULES.entity, 'Has Resource by Entity', 234, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.entity, 'Entity Resource', 235, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS], 
+        [MODULES.vote, 'Top1 Option by Votes', 191, [], ValueType.TYPE_STRING], 
+        [MODULES.vote, 'Top1 Count by Votes', 192, [], ValueType.TYPE_U64], */
+
+        [MODULES.wowok, 'Builder', 210, [], ValueType.TYPE_ADDRESS, 'Builder address of Wowok.'], 
+        [MODULES.wowok, 'Everyone Guard', 211, [], ValueType.TYPE_ADDRESS, 'A guard that all addresses can pass through.'], 
+        [MODULES.wowok, 'Object of Entities', 212, [], ValueType.TYPE_ADDRESS, 'The address of entity information object.'],
+        [MODULES.wowok, 'Grantor Count', 213, [], ValueType.TYPE_U64, 'Number of registered grantors.'],   
+        [MODULES.wowok, 'Has Grantor', 214, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address has been registered as a grantor?', , 'Input:address'], 
+        [MODULES.wowok, 'Grantor Name', 215, [ValueType.TYPE_ADDRESS], ValueType.TYPE_STRING, "Name of a grantor.", 'Input:address'], 
+        [MODULES.wowok, 'Grantor Registration Time', 216, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Registration time of a grantor.', 'Input:address'], 
+        [MODULES.wowok, 'Grantor Expired Time', 217, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The expiration time of a grantor.', 'Input:address'], 
+        [MODULES.wowok, 'Grantee Object for Grantor', 218, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'Grantee repository address of a grantor.', 'Input:address'], 
+
+        [MODULES.entity, 'Contains Entity?', 230, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is an entity already registered?', 'Input:address'], 
+        [MODULES.entity, 'Likes', 231, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of likes for an address by other addresses.', 'Input:address'], 
+        [MODULES.entity, 'Dislikes', 232, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of dislikes for an address by other addresses.', 'Input:address'], 
+        [MODULES.entity, 'Entity Info', 233, [ValueType.TYPE_ADDRESS], ValueType.TYPE_VEC_U8, 'Public information about an entity.', 'Input:address'], 
+        [MODULES.entity, 'Has Resource by Entity?', 234, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an entity created a resource?', 'Input:address'], 
+        [MODULES.entity, 'Entity Resource', 235, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address of a resource object created by an entity.', 'Input:address'], 
     ];
 
     static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);
@@ -266,16 +268,32 @@ export class Guard {
     }
     static NumberOptions = () : Guard_Options[] => {
         const r: Guard_Options[] = [...Guard.CmdFilter(ValueType.TYPE_U8), ...Guard.CmdFilter(ValueType.TYPE_U64), 
-            ...Guard.CmdFilter(ValueType.TYPE_U128), ...Guard.CmdFilter(ValueType.TYPE_U256)].map((v)=> { return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
-        r.push({from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'});
-        return r;
+            ...Guard.CmdFilter(ValueType.TYPE_U128), ...Guard.CmdFilter(ValueType.TYPE_U256)].map((v)=> { 
+                return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
+        return r.concat(Guard.Crunchings);
     }
+
+    static Signer:Guard_Options = {from:'type', name:'Txn Signer', value:ContextType.TYPE_SIGNER, group:'Txn Functions'};
+    static Time:Guard_Options = {from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'};
+    static Logics = () :Guard_Options[] => LogicsInfo.map((v) => { return {from:'type', name:v[1] as string, value:v[0] as number, group:'Compare or Logic'}});
+    static Crunchings: Guard_Options[] = [
+        {from:'type', name:'Txn Time', value:ContextType.TYPE_CLOCK, group:'Txn Functions'},
+        {from:'type', name:'PositiveNumber Add (+)', value:OperatorType.TYPE_NUMBER_ADD, group:'Number Crunching'},
+        {from:'type', name:'PositiveNumber Subtract (-)', value:OperatorType.TYPE_NUMBER_SUBTRACT, group:'Number Crunching'},
+        {from:'type', name:'PositiveNumber Multiply (*)', value:OperatorType.TYPE_NUMBER_MULTIPLY, group:'Number Crunching'},
+        {from:'type', name:'PositiveNumber Devide (/)', value:OperatorType.TYPE_NUMBER_DEVIDE, group:'Number Crunching'},
+        {from:'type', name:'PositiveNumber Mod (%)', value:OperatorType.TYPE_NUMBER_MOD, group:'Number Crunching'},
+    ]
+
     static CommonOptions = (retType:ValueType) : Guard_Options[] => {
         return Guard.CmdFilter(retType).map((v)=> {return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
     }
+
     static AllOptions = () :  Guard_Options[] => {
-        return Guard.QUERIES.map((v)=>{return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
+        var r:Guard_Options[] =  Guard.QUERIES.map((v)=>{return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
+        return [...r, ...Guard.Crunchings, ...Guard.Logics(), Guard.Signer, Guard.Time]
     }
+
     static StringOptions = () : Guard_Options[] => {
         return [...Guard.CmdFilter(ValueType.TYPE_VEC_U8), ...Guard.CmdFilter(ValueType.TYPE_STRING)].map((v) => {
             return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])};
@@ -283,12 +301,11 @@ export class Guard {
     }
     static BoolOptions = () : Guard_Options[] => {
         const n1:Guard_Options[] = Guard.BoolCmd.map((v)=> { return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
-        const n2:Guard_Options[] = LogicsInfo.map((v) => { return {from:'type', name:v[1] as string, value:v[0] as number, group:'Compare or Logic'}});
-        return [...n1, ...n2]
+        return [...n1, ...Guard.Logics()];
     }
     static AddressOptions = () : Guard_Options[] => {
         const n1:Guard_Options[] = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_ADDRESS).map((v)=> { return {from:'query', name:v[1], value:v[2], group:FirstLetterUppercase(v[0])}});
-        n1.push({from:'type', name:'Txn Signer', value:ContextType.TYPE_SIGNER, group:'Txn Functions'});
+        n1.push(Guard.Signer);
         return [...n1]
     }
 
@@ -345,9 +362,13 @@ export class GuardConstantHelper {
         } 
     }
     
-    static add_constant(constants:GuardConstant, identifier:number, type:ValueType, value:any, bNeedSerialize=true) {
-        if (!GuardConstantHelper.IsValidIndentifier(identifier)) return false;
-        if (!value) return false;
+    static add_constant(constants:GuardConstant, identifier:number, type:ValueType|ContextType, value:any, bNeedSerialize=true) {
+        if (!GuardConstantHelper.IsValidIndentifier(identifier)) {
+            ERROR(Errors.InvalidParam, 'add_constant identifier')
+        }
+        if (!value) {
+            ERROR(Errors.InvalidParam, 'add_constant value')
+        }
     
         switch (type) {
             case ValueType.TYPE_BOOL:
@@ -368,18 +389,16 @@ export class GuardConstantHelper {
             case ValueType.TYPE_VEC_BOOL:
             case ValueType.TYPE_VEC_U128:
             case ValueType.TYPE_VEC_U256:
+            case ValueType.TYPE_STRING:  
+            case ValueType.TYPE_VEC_U8: 
                 let ser = SER_VALUE.find(s=>s.type==type);
                 if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type');
-                bNeedSerialize ? constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.type as number, value)}) :
-                constants.set(identifier,  {type:type, value:value})    
-                return         
-            case ValueType.TYPE_VEC_U8:
-                if (typeof(value) === 'string') {
-                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ValueType.TYPE_STRING, value)})                 
+                if (bNeedSerialize) {
+                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.type as number, value)}) 
                 } else {
-                    constants.set(identifier,  {type:type, value:value})      
+                    constants.set(identifier, {type:type, value:value}) 
                 }
-                return;  
+                return    
             default:
                 ERROR(Errors.Fail, 'add_constant  serialize not impl yet')
         }
@@ -388,7 +407,7 @@ export class GuardConstantHelper {
 export class GuardMaker {
     protected data : Uint8Array[] = [];
     protected type_validator : Data_Type[] = [];
-    protected constant : GuardConstant = new Map();
+    protected constant : GuardConstant = new Map<number, Guard_Variable>();
 
     private static index: number = 0;
     private static get_index() { 
@@ -400,8 +419,8 @@ export class GuardMaker {
 
     constructor() { }
 
-    add_constant(type:ConstantType, value:any, bNeedSerialize=true) : number {
-        let identifier = GuardMaker.get_index();
+    add_constant(type:ConstantType, value:any, identifier?:number, bNeedSerialize=true) : number {
+        if (identifier === undefined) identifier = GuardMaker.get_index();
         if (type == ContextType.TYPE_WITNESS_ID) {
             // add witness to constant
             GuardConstantHelper.add_future_constant(this.constant, identifier, value, undefined, bNeedSerialize);
@@ -443,9 +462,10 @@ export class GuardMaker {
         case ValueType.TYPE_VEC_U256:
             this.serValueParam(type, param);
             break;
+        case ValueType.TYPE_STRING:
         case ValueType.TYPE_VEC_U8:
             if (!param) ERROR(Errors.InvalidParam, 'param');
-            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
+            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));
             } else {
@@ -538,6 +558,7 @@ export class GuardMaker {
 
     add_logic(type:OperatorType) : GuardMaker {
         let splice_len = 2;
+        let ret = ValueType.TYPE_BOOL;
         switch (type) {
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
@@ -565,17 +586,52 @@ export class GuardMaker {
                 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')  }
+                break;
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
                 break;
+            case OperatorType.TYPE_NUMBER_ADD:
+            case OperatorType.TYPE_NUMBER_DEVIDE:
+            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')  }
+                ret = ValueType.TYPE_U256;
+                break;
             default:
                 ERROR(Errors.InvalidParam, 'add_logic type invalid' + type) 
         }
         this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE     
         this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack   
-        this.type_validator.push(ValueType.TYPE_BOOL); // add bool to type stack
+        this.type_validator.push(ret); // add bool to type stack
         return this;
     }
 
+    static IsNumberType(type:Data_Type) : boolean {
+        return (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 || type === ValueType.TYPE_U256)
+    }
+
+    hasIdentifier(id:number) : boolean {
+        return this.constant.has(id)
+    }
+
     build(bNot = false) : GuardMaker {
         //console.log(this.type_validator);
         //this.data.forEach((value:Uint8Array) => console.log(value));

package/src/machine.ts

@@ -144,10 +144,17 @@ export class Machine {
                 });                
             }            
         } else if (forward?.permission !== undefined && IsValidU64(forward.permission)) {
-            f = this.txb.moveCall({ 
-                target:Protocol.Instance().MachineFn('forward3') as FnCallType,
-                    arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight)]
-            });    
+            if (forward?.guard) {
+                f = this.txb.moveCall({ 
+                    target:Protocol.Instance().MachineFn('forward3') as FnCallType,
+                        arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight), this.txb.object(Protocol.TXB_OBJECT(this.txb, forward.guard))]
+                });    
+            } else {
+                f = this.txb.moveCall({ 
+                    target:Protocol.Instance().MachineFn('forward4') as FnCallType,
+                        arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight)]
+                });  
+            }
         } else {
             ERROR(Errors.InvalidParam, 'forward')
         }
@@ -511,8 +518,8 @@ export class Machine {
         if (!IsValidName(forward.name)) return 'Forward name invalid'
         if (forward?.namedOperator && !IsValidName_AllowEmpty(forward?.namedOperator)) return 'Progress Operator invalid';
         if (forward?.permission && !Permission.IsValidPermissionIndex(forward?.permission)) return 'Permission index invalid';
-        if (!forward?.permission && !forward?.namedOperator) return 'Both Permission index and Progress Operator empty';
-        if (forward?.weight && !IsValidUintLarge(forward.weight)) return 'Weight invalid';
+        if (!forward?.permission && !forward?.namedOperator) return 'Business-Permissions invalid';
+        if (forward?.weight && !IsValidU64(forward.weight)) return 'Weight invalid';
         return ''
     }
 

package/src/passport.ts

@@ -50,6 +50,7 @@ export interface FutureFill {
     future?: string;
     cmd?: number;
     type?: string;
+    identifier?: number;
 }
 export interface PassportQuery {
     guard: (string | TransactionObjectInput)[];
@@ -95,13 +96,17 @@ export class GuardParser {
                 case ValueType.TYPE_OPTION_U64:
                 case ValueType.TYPE_OPTION_U256:
                 case ValueType.TYPE_VEC_U256:
+                case ValueType.TYPE_STRING:
+                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);
                     if (!de) ERROR(Errors.Fail, 'GuardObject de error')
                     value = Bcs.getInstance().de(de!.type as number, Uint8Array.from(v.value));
                     break;
 
                 default:
-                    ERROR(Errors.Fail, 'GuardObject constant type invalid')
+                    ERROR(Errors.Fail, 'GuardObject constant type invalid:' + v.type)
             }
             constants.push({identifier:v.identifier, type:v.type,  value:value});
         });
@@ -126,6 +131,15 @@ export class GuardParser {
                 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 ContextType.TYPE_CONSTANT:
                     identifier = arr.shift()! as number;  // identifier
@@ -305,7 +319,19 @@ export class GuardParser {
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
             case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
-                current.ret_type = ValueType.TYPE_BOOL;
+            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:
+                if (current.type === OperatorType.TYPE_LOGIC_AS_U256_GREATER || current.type === OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL ||
+                    current.type === OperatorType.TYPE_LOGIC_AS_U256_LESSER || current.type === OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL ||
+                    current.type === OperatorType.TYPE_LOGIC_AS_U256_EQUAL) {
+                        current.ret_type = ValueType.TYPE_BOOL;
+                } else {
+                    current.ret_type = ValueType.TYPE_U256;
+                }
+                
                 if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
                 for (let i = 0; i < 2; ++i) {
                     let p = stack.pop() as DeGuardData;
@@ -322,6 +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)
                 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');
 
@@ -392,6 +419,7 @@ export class GuardParser {
             case ValueType.TYPE_OPTION_U256:
             case ValueType.TYPE_OPTION_U64:
             case ValueType.TYPE_OPTION_U8:
+            case ValueType.TYPE_STRING:
                 current.ret_type = current.type;
                 stack.push(current);
                 return;
@@ -498,15 +526,15 @@ export class GuardParser {
         this.guard_list.forEach((g) => {
             g.query_list.forEach((v) => {
                 if (typeof(v) !== 'string') {
-                    ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, cmd:v.cmd});
+                    ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, cmd:v.cmd, identifier:v?.identifier});
                 }
             })
             // cmd already in query_list, so filter it out.
             g.constant.filter((v)=>v.type === ContextType.TYPE_WITNESS_ID && v.cmd === undefined).forEach((v) => {
-                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
+                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, identifier:v?.identifier});
             })
             g.input_witness.forEach((v) => {
-                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
+                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, identifier:v?.identifier});
             })
         }); return ret;
     }
@@ -542,6 +570,11 @@ export class GuardParser {
                 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 ContextType.TYPE_CONSTANT:
                 arr.splice(0, 1); // identifier of constant

package/src/permission.ts

@@ -78,7 +78,7 @@ export enum PermissionIndex {
     progress_context_repository = 653,
     progress_unhold = 654,
     progress_parent = 655,
-    user_defined_start = 10000,
+    user_defined_start = 1000,
 }
 
 export interface PermissionInfoType {
@@ -549,9 +549,10 @@ export class  Permission {
     static PERMISSION_OWNER = 1;
     static PERMISSION_ADMIN = 2;
     static PERMISSION_OWNER_AND_ADMIN = 3;
+    static BUSINESS_PERMISSIONS_START = PermissionIndex.user_defined_start;
 
     static IsValidUserDefinedIndex = (index:number)  => { 
-        return index >= PermissionIndex.user_defined_start && IsValidUintLarge(index)
+        return index >= Permission.BUSINESS_PERMISSIONS_START && IsValidUintLarge(index)
     }
     
     static IsValidPermissionIndex = (index:PermissionIndexType) : boolean  => {

package/src/progress.ts

@@ -268,22 +268,23 @@ export class Progress {
             ERROR(Errors.IsValidAddress, 'sub_id');
         }
         
-        let diliverable = this.txb.pure.option('address', deliverables_address ? deliverables_address  : undefined);
-        let sub = this.txb.pure.option('address', sub_id ? sub_id : undefined);
-        
+        const diliverable = this.txb.pure.option('address', deliverables_address ? deliverables_address  : undefined);
+        const sub = this.txb.pure.option('address', sub_id ? sub_id : undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().ProgressFn('next_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), diliverable, sub, 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    Protocol.TXB_OBJECT(this.txb, this.permission), this.txb.object(clock)],
             })    
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().ProgressFn('next') 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), diliverable, sub, Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.pure.string(next.forward), diliverable, sub, Protocol.TXB_OBJECT(this.txb, this.permission), this.txb.object(clock)],
             })               
         }
     }

package/src/protocol.ts

@@ -62,6 +62,11 @@ export type FnCallType = `${string}::${string}::${string}`;
 
 export enum OperatorType {
     TYPE_QUERY = 1, // query wowok object
+    TYPE_NUMBER_ADD = 2,
+    TYPE_NUMBER_SUBTRACT = 3, 
+    TYPE_NUMBER_MULTIPLY = 4, 
+    TYPE_NUMBER_DEVIDE = 5, 
+    TYPE_NUMBER_MOD = 6,
 
     TYPE_LOGIC_AS_U256_GREATER = 11,
     TYPE_LOGIC_AS_U256_GREATER_EQUAL = 12,
@@ -74,20 +79,28 @@ 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 = [
-    [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'PositiveNumber >'],
-    [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'PositiveNumber >='],
-    [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'PositiveNumber <'],
-    [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'PositiveNumber <='],
-    [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'PositiveNumber ='],
-    [OperatorType.TYPE_LOGIC_EQUAL, 'Strict ='],
+    [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'Unsigned Integer >'],
+    [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'Unsigned Integer >='],
+    [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_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 {
@@ -123,21 +136,26 @@ export enum RepositoryValueType {
     PositiveNumber_Vec = 203,
     String = 204,
     String_Vec = 205,
+    Bool = 206,
 }
 
 export const RepositoryValueTypeInfo = [
-    {type: RepositoryValueType.String, name:'String', description:'String.'},
-    {type: RepositoryValueType.Address, name:'Address', description:'Object id or Personal address.'},
-    {type: RepositoryValueType.PositiveNumber, name:'Positive number or Zero', description:'Positive number or 0. including u8, u16 ,..., u256'},
-    {type: RepositoryValueType.String_Vec, name:'String vector',  description:'Vector of string.'},
-    {type: RepositoryValueType.Address_Vec, name:'Address vector', description:'Vector of address.'},
-    {type: RepositoryValueType.PositiveNumber_Vec, name:'Positive number or Zero vector', description:'Vector of positive number or 0'},
+    {type: RepositoryValueType.String, name:'string', description:'String.'},
+    {type: RepositoryValueType.Address, name:'address', description:'Object id or Personal address.'},
+    {type: RepositoryValueType.PositiveNumber, name:'unsigned integer', description:'Including u8, u16 ,..., u256'},
+    {type: RepositoryValueType.String_Vec, name:'string vector',  description:'Vector of string.'},
+    {type: RepositoryValueType.Address_Vec, name:'address vector', description:'Vector of address.'},
+    {type: RepositoryValueType.PositiveNumber_Vec, name:'unsigned integer vector', description:'Vector of unsigned integer'},
+    {type: RepositoryValueType.Bool, name:'bool', description:'True or False.'},
 ]
 
 export const OperatorTypeArray = (Object.values(OperatorType) as []).filter((v)=>typeof(v) === 'number') as number[];
 export const ValueTypeArray = (Object.values(ValueType) as []).filter((v)=>typeof(v) === 'number') as number[];
 export const IsValidOperatorType = (type:number) : boolean => { return OperatorTypeArray.includes(type)}
 export const IsValidValueType = (type:number) : boolean => { return ValueTypeArray.includes(type)}
+export const IsNumberType = (type:ValueType | any) : boolean => { return type===ValueType.TYPE_U128 || type===ValueType.TYPE_U256 ||
+    type===ValueType.TYPE_U64 || type===ValueType.TYPE_U8 
+}
 
 export enum ContextType {
     TYPE_SIGNER  = 60,
@@ -155,7 +173,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: machine's future progress, service's future order",  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_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},
@@ -175,7 +193,7 @@ export const SER_VALUE: ValueTypeString[] = [
     {type: ValueType.TYPE_OPTION_U256, name: 'option', description:'option of u256. eg:none or u256 value'},
     {type: ValueType.TYPE_VEC_U256, name: '[number]', description:'unsigned-256 number array. eg:[123, 778888, 42312]'},
     {type: ValueType.TYPE_VEC_STRING, name: '[string]', description:'ascii string array. eg:["abc", "hi"]'},
-    {type: ValueType.TYPE_STRING, name: 'string', description:'ascii string. eg:"wowok"', },
+    {type: ValueType.TYPE_STRING, name: 'string', description:'eg:"wowok"', },
     {type: ValueType.TYPE_OPTION_STRING, name: 'option', description:'option of string. eg:none or string value'},
     {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233', validator:IsValidUintLarge},
 ]
@@ -189,14 +207,20 @@ export enum ENTRYPOINT {
     devnet = 'devnet',
     localnet = 'localnet'
 }
-
+/*
 const TESTNET = {
-    package: "0x98e5209cf5cf31a38ebde562681441d7544f38ee6a879266dc7273160635f6ba",
-    wowok_object: '0x676243951ed0d32341680b10d888887dfb39603b1af747036164e90fdfed1274',
-    entity_object: '0xe32334d663d0e7d058682b5170632672a11df1cdaa3f522859e75b451bdc67d5',
-    treasury_cap:'0x10bec6d987cf7fc16fc62246f3c382d84ee285d9ec9f038bc03845fe620bf2d3',
+    package: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
+    wowok_object: '0xb0a521a287e9d5e08932b3984dbe6ce159e836179c41bd08c556ef77ecdb7439',
+    entity_object: '0x16aab98920e7341d1dc19631031253234b2b71fc2ab8c32d65ee3ded8072acef',
+    treasury_cap:'0xb75a2ca2f651755c134ad521175f33f9e3f9008ad44340f76b3229e1f30cfdff',
+}
+*/
+const TESTNET = {
+    package: "0x72a2ee21e11ee0c0d8fd9212127b12be0cdf7722b1e91c85a15a79cff3f7d9b0",
+    wowok_object: '0x3e69e10a8ab426c5e6d4392841bb6f6b9b45b7fa5feb9fcf23d7616a2effba0c',
+    entity_object: '0x53606d845cdedf0b256d27b3c0b0764265b2c272f3ad743a018ea4e8e59f3c74',
+    treasury_cap:'0xbbbc1fcab63e3373d53669507d7a6042282edef398273dcc04fe24db47c4881d',
 }
-
 const MAINNET = {
     package: "",
     wowok_object: '',

package/src/repository.ts

@@ -22,16 +22,16 @@ export type Repository_Policy = {
     key:string;
     description: string;
     data_type: RepositoryValueType;
-    permission?: PermissionIndexType; // PermissionIndex like, must be geater than 10000
+    permission?: PermissionIndexType; // PermissionIndex like, must be geater than 1000
 }
 export type Repository_Policy_Data = {
     key: string;
-    data: Repository_Value[];
-    value_type?: ValueType;
+    data: Repository_Value[];  
+    value_type?: ValueType; // 
 }
 export type Repository_Value = {
     address: string; // UID: address or objectid
-    bcsBytes: Uint8Array;
+    bcsBytes: Uint8Array; // BCS contents. Notice that: First Byte be the Type by caller, or specify type with 'Repository_Policy_Data.value_type' field.
 }
 
 export class Repository {
@@ -425,6 +425,8 @@ export class Repository {
                     d = '0x' + d;
                 } else if (type === ValueType.TYPE_VEC_ADDRESS) {
                     d = d.map((v:string) => { return ('0x' + v) } );
+                } else if (type === ValueType.TYPE_BOOL) {
+                    d = d ? 'True' : 'False'
                 }
             };
             return {object:v?.data?.content?.fields?.id?.id, id:(v?.data?.content?.fields as any)?.name?.fields?.id, 
@@ -454,7 +456,7 @@ export class Repository {
         } return undefined
     }
 
-    static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | string[]) : {type:ValueType, data: Uint8Array} | undefined =>  {
+    static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | boolean | string[]) : {type:ValueType, data: Uint8Array} | undefined =>  {
         if (dataType === RepositoryValueType.String) { 
             return {type: ValueType.TYPE_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, new TextEncoder().encode(data.toString()))}
        } else if (dataType === RepositoryValueType.PositiveNumber) {
@@ -491,6 +493,9 @@ export class Repository {
                 return new TextEncoder().encode(v);
             })
             return {type: ValueType.TYPE_VEC_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_VEC_U8, r)}
+       } else if (dataType === RepositoryValueType.Bool) {
+            if (typeof(data) !== 'boolean') return undefined;
+            return {type:ValueType.TYPE_BOOL, data:Bcs.getInstance().ser(ValueType.TYPE_BOOL, data)}       
        }
        return undefined
     }

package/src/utils.ts

@@ -2,7 +2,7 @@ import { BCS, getSuiMoveConfig, } from '@mysten/bcs';
 import { SuiObjectResponse, DynamicFieldPage } from '@mysten/sui/client';
 import { ERROR, Errors } from './exception';
 import { isValidSuiAddress} from '@mysten/sui/utils'
-import { RepositoryValueType, ValueType, Protocol } from './protocol'
+import { RepositoryValueType, ValueType, Protocol, ContextType, OperatorType } from './protocol'
 
 export const MAX_U8 = BigInt('255');
 export const MAX_U64 = BigInt('18446744073709551615');
@@ -13,7 +13,7 @@ export const OPTION_NONE = 0;
 
 export const ValueTypeConvert = (type:ValueType | null | undefined) : RepositoryValueType | number => {
     if (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 || 
-        type === ValueType.TYPE_U256 || type === ValueType.TYPE_BOOL) {
+        type === ValueType.TYPE_U256) {
             return RepositoryValueType.PositiveNumber
     } else if (type === ValueType.TYPE_VEC_U8 || type === ValueType.TYPE_VEC_U64 || type === ValueType.TYPE_VEC_U128 || 
         type === ValueType.TYPE_VEC_U256|| type === ValueType.TYPE_VEC_BOOL) {
@@ -26,7 +26,9 @@ export const ValueTypeConvert = (type:ValueType | null | undefined) : Repository
         return RepositoryValueType.String
     } else if (type === ValueType.TYPE_VEC_STRING) {
         return RepositoryValueType.String_Vec
-    } 
+    } else if (type === ValueType.TYPE_BOOL) {
+        return RepositoryValueType.Bool
+    }
     return -1;
 }
 
@@ -192,7 +194,7 @@ export class Bcs {
         return this.bcs.ser('Option<u32>', {'some': data}).toBytes();
     }
 
-    ser(type:ValueType | string, data:Uint8Array | any) : Uint8Array {
+    ser(type:ValueType | ContextType | string, data:Uint8Array | any) : Uint8Array {
         if (typeof(type) === 'string') {
             return this.bcs.ser(type, data).toBytes();
         }
@@ -242,6 +244,8 @@ export class Bcs {
                 return this.bcs.ser(BCS.STRING, data).toBytes();
             case ValueType.TYPE_VEC_STRING:
                 return this.bcs.ser('vector<string>', data).toBytes();
+            case ContextType.TYPE_WITNESS_ID:
+                return this.bcs.ser(BCS.ADDRESS, data).toBytes();
             default:
                 ERROR(Errors.bcsTypeInvalid, 'ser');
         }
@@ -411,6 +415,9 @@ export const IsValidU64 = (value:string | number | undefined | bigint) : boolean
 export const IsValidU128 = (value:string | number | undefined | bigint) : boolean => {
     return IsValidBigint(value, MAX_U128, BigInt(0))
 }
+export const IsValidU256 = (value:string | number | undefined | bigint) : boolean => {
+    return IsValidBigint(value, MAX_U256, BigInt(0))
+}
 
 export const IsValidTokenType = (argType: string) : boolean => { 
     if (!argType || argType.length === 0) {