wowok 1.2.7 → 1.2.9

package/src/protocol.ts

@@ -3,7 +3,7 @@ import { SuiClient, SuiObjectResponse, SuiObjectDataOptions, SuiTransactionBlock
 import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
 import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
 import { TransactionBlock, Inputs, TransactionResult, TransactionArgument } from '@mysten/sui.js/transactions';
-import { capitalize, IsValidArray } from './utils'
+import { capitalize, IsValidAddress, IsValidArray, IsValidU128, IsValidU64, IsValidU8, IsValidUintLarge } from './utils'
 import { GuardConstant } from './guard';
 import { isValidSuiAddress, isValidSuiObjectId } from '@mysten/sui.js/utils'
 
@@ -76,11 +76,25 @@ export enum OperatorType {
     TYPE_LOGIC_OR = 21, // 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_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'], 
+];
+
 export enum ValueType {
     TYPE_BOOL = 100,
     TYPE_ADDRESS = 101,
-    TYPE_U64 = 102,
-    TYPE_U8 = 103,
+    TYPE_U8 = 102,
+    TYPE_U64 = 103,
     TYPE_VEC_U8 = 104,
     TYPE_U128 = 105,
     TYPE_VEC_ADDRESS = 106,
@@ -101,6 +115,7 @@ export enum ValueType {
     TYPE_VEC_STRING = 121,
     TYPE_U256 = 122,
 }
+
 export enum RepositoryValueType {
     Address = 200,
     Address_Vec = 201,
@@ -111,58 +126,42 @@ export enum RepositoryValueType {
 }
 
 export const RepositoryValueTypeInfo = [
-    {type: RepositoryValueType.Address, name:'Address', description:'Object id or Personal address.'},
-    {type: RepositoryValueType.Address_Vec, name:'Address vector', description:'Vector of address.'},
     {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.PositiveNumber, name:'Positive number', description:'Positive number. including u8, u16 ,..., u256'},
-    {type: RepositoryValueType.PositiveNumber_Vec, name:'Positive number vector', description:'Vector of positive number'},
-]
-
-export const ValueTypeInfo = [
-    {type:ValueType.TYPE_BOOL, name:'bool'},
-    {type:ValueType.TYPE_ADDRESS, name:'address'},
-    {type:ValueType.TYPE_U64, name:'u64'},
-    {type:ValueType.TYPE_U8, name:'u8'},
-    {type:ValueType.TYPE_VEC_U8, name:'vec-u8'},
-    {type:ValueType.TYPE_U128, name:'u128'},
-    {type:ValueType.TYPE_VEC_ADDRESS, name:'vec-address'},
-    {type:ValueType.TYPE_VEC_BOOL, name:'vec-bool'},
-    {type:ValueType.TYPE_VEC_VEC_U8, name:'vec-vec-u8'},
-    {type:ValueType.TYPE_VEC_U64, name:'vec-u64'},
-    {type:ValueType.TYPE_VEC_U128, name:'vec-u128'},
-    {type:ValueType.TYPE_OPTION_ADDRESS, name:'opt-address'},
-    {type:ValueType.TYPE_OPTION_BOOL, name:'opt-bool'},
-    {type:ValueType.TYPE_OPTION_U8, name:'opt-u8'},
-    {type:ValueType.TYPE_OPTION_U64, name:'opt-u64'},
-    {type:ValueType.TYPE_OPTION_U128, name:'opt-u128'},
-    {type:ValueType.TYPE_OPTION_U256, name:'opt-u256'},
-    {type:ValueType.TYPE_OPTION_STRING, name:'opt-string'},
-    {type:ValueType.TYPE_OPTION_VEC_U8, name:'opt-vec-u8'},
-    {type:ValueType.TYPE_VEC_U256, name:'vec-u256'},
-    {type:ValueType.TYPE_STRING, name:'string'},
-    {type:ValueType.TYPE_VEC_STRING, name:'vec-string'},
-    {type:ValueType.TYPE_U256, name:'u256'},
+    {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'},
 ]
 
 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) => { return OperatorTypeArray.includes(type)}
-export const IsValidValueType = (type:number) => { return ValueTypeArray.includes(type)}
+export const IsValidOperatorType = (type:number) : boolean => { return OperatorTypeArray.includes(type)}
+export const IsValidValueType = (type:number) : boolean => { return ValueTypeArray.includes(type)}
 
+export enum ContextType {
+    TYPE_SIGNER  = 60,
+    TYPE_CLOCK = 61,
+    TYPE_WITNESS_ID = 62, 
+    TYPE_CONSTANT = 80,
+}
 interface ValueTypeString {
-    type: ValueType;
+    type: ValueType | ContextType;
     name: string;
     description: string;
+    validator?: (value:any) => boolean;
 }
 
 export const SER_VALUE: ValueTypeString[] = [
-    {type: ValueType.TYPE_BOOL, name: 'bool', description:'boolean. eg:true or false'},
-    {type: ValueType.TYPE_ADDRESS, name: 'address', description:'address or object-id. eg:0x6789af'},
-    {type: ValueType.TYPE_U64, name: 'number', description:'unsigned-64 number. eg:23870233'},
-    {type: ValueType.TYPE_U8, name: 'number', description:'unsigned-8 number. eg:255'},
-    {type: ValueType.TYPE_VEC_U8, name: '[number]', description:'unsigned-8 number array. eg:"[1,2,3]"'},
-    {type: ValueType.TYPE_U128, name: 'number', description:'unsigned-8 number. eg:12348900999'},
+    {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_SIGNER, name: 'txn signer', description:"signer address of the transaction, ", validator:IsValidAddress},
+    {type: ContextType.TYPE_CLOCK, name: 'txn time', description:"unsigned-64 number for the transaction time", validator:IsValidU64},
+    {type: ValueType.TYPE_U64, name: 'number', description:'unsigned-64 number. eg:23870233', validator:IsValidU64},
+    {type: ValueType.TYPE_U8, name: 'number', description:'unsigned-8 number. eg:255', validator:IsValidU8},
+    {type: ValueType.TYPE_VEC_U8, name: 'string', description:'string or unsigned-8 number array. eg:"[1,2,3]"'},
+    {type: ValueType.TYPE_U128, name: 'number', description:'unsigned-8 number. eg:12348900999', validator:IsValidU128},
     {type: ValueType.TYPE_VEC_ADDRESS, name: '[address]', description:'address array. eg:[0x2277f2, 0x3344af]'},
     {type: ValueType.TYPE_VEC_BOOL, name: '[bool]', description:'boolean array. eg:[true, false, true]'},
     {type: ValueType.TYPE_VEC_VEC_U8, name: '[[number]]', description:'array of unsigned-8 number array. eg:["i", "like", "wowok"]'},
@@ -176,18 +175,11 @@ 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:'ascii string. 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'},
+    {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233', validator:IsValidUintLarge},
 ]
 
-export enum ContextType {
-    TYPE_SIGNER  = 60,
-    TYPE_CLOCK = 61,
-    TYPE_WITNESS_ID = 62, 
-    TYPE_CONSTANT = 80,
-}
-
 export type ConstantType = ValueType | ContextType.TYPE_WITNESS_ID;
 export type Data_Type = ValueType | OperatorType | ContextType;
 
@@ -199,9 +191,9 @@ export enum ENTRYPOINT {
 }
 
 const TESTNET = {
-    package: "0x852fa17575b1ae11932b475110bf46981458fdb67a2f07b922022e1516560fad",
-    wowok_object: '0xf98cc6d8bd9feadc5dce7365270b4ffb32f69a5320ab739193d301103e686e8c',
-    entity_object: '0xe0469c187499273ec39a575cc28d4d93f0a66b11e1b92028c61bc69bfc1167c6',
+    package: "0x8ba9f90c9a0e5f2199a92fdc5ea255ac9df5471289cfe40a87ac90f25d93dd5b",
+    wowok_object: '0x9d33a57a09f3ff73ba51afe6ed2e671e7d78b771e34b0a1ba66e52264e34b3fd',
+    entity_object: '0xb759e1e5569f1f8d5ae30efb6efec0a639c5ef70a7c7abcc012919cf5dae33af',
 }
 
 const MAINNET = {
@@ -279,7 +271,6 @@ export class Protocol {
     };
     
     MachineFn = (fn:any) => { return `${this.package}::${MODULES.machine}::${fn}`};
-    NodeFn = (fn: any) => { return `${this.package}::${MODULES.node}::${fn}`};
     ProgressFn = (fn:any) => { return `${this.package}::${MODULES.progress}::${fn}`};
     CommunityFn = (fn: any) => { return `${this.package}::${MODULES.community}::${fn}`};
     RepositoryFn = (fn:any) => { return `${this.package}::${MODULES.repository}::${fn}`};

package/src/repository.ts

@@ -1,15 +1,22 @@
 import { BCS } from '@mysten/bcs';
 import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
 import { PermissionIndexType, Permission } from './permission'
-import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone, IsValidName,  } from './utils';
+import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone, IsValidName,  ValueTypeConvert} from './utils';
 import { ERROR, Errors } from './exception';
-import { Resource } from './resource';
+import { MAX_U8, MAX_U128, MAX_U256, MAX_U64 } from './utils';
 
 export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
     POLICY_MODE_STRICT = 1,
 }
 
+export interface RepData {
+    id: string;
+    name: string;
+    dataType: RepositoryValueType;
+    data: string | string[];
+    object: string;
+}
 
 export type Repository_Policy = {
     key:string;
@@ -143,14 +150,11 @@ export class Repository {
         })  
     }
     add_reference(references:string[], passport?:PassportObject) {
-        if (!references) {
-            ERROR(Errors.InvalidParam, 'add_reference')
-        }
-
+        if (references.length === 0)  return;
         if (!IsValidArray(references, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'add_reference')
         }
-        console.log(array_unique(references))
+
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
@@ -169,11 +173,9 @@ export class Repository {
         }
     }
     remove_reference(references:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!references && !removeall) {
-            ERROR(Errors.InvalidParam, 'remove_reference')
-        }
+        if (references.length === 0 && !removeall)  return
 
-        if (references && !IsValidArray(references, IsValidAddress)) {
+        if (!IsValidArray(references, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'remove_reference')
         }
 
@@ -212,9 +214,7 @@ export class Repository {
     }
     // add or modify the old 
     add_policies(policies:Repository_Policy[], passport?:PassportObject)  {
-        if (!policies) {
-            ERROR(Errors.InvalidParam, 'policies')
-        }
+        if (policies.length === 0) return;
 
         let bValid = true;
         policies.forEach((p) => {
@@ -252,10 +252,8 @@ export class Repository {
     }
 
     remove_policies(policy_keys:string[], passport?:PassportObject)  {
-        if (!policy_keys) {
-            ERROR(Errors.AllInvalid, 'policy_keys & removeall')
-        }
-        if (policy_keys && !IsValidArray(policy_keys, Repository.IsValidName)){
+        if (policy_keys.length === 0) return ;
+        if (!IsValidArray(policy_keys, Repository.IsValidName)){
             ERROR(Errors.InvalidParam, 'policy_keys')
         }
 
@@ -286,14 +284,14 @@ export class Repository {
             txb.moveCall({
                 target:this.protocol.RepositoryFn('policy_rename_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
-                    txb.pure(policy_key, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    txb.pure(policy_key), txb.pure(new_policy_key), 
                     Protocol.TXB_OBJECT(txb, this.permission)]
             })     
         } else {
             txb.moveCall({
                 target:this.protocol.RepositoryFn('policy_rename') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), 
-                    txb.pure(policy_key, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    txb.pure(policy_key), txb.pure(new_policy_key), 
                     Protocol.TXB_OBJECT(txb, this.permission)]
             })       
         }
@@ -421,5 +419,94 @@ export class Repository {
         }
         return '';
     }
+
+    static rpc_de_data(fields:any) : RepData [] {
+        const rep: RepData[] = fields?.map((v:any) => {
+            const value = new Uint8Array((v?.data?.content?.fields as any)?.value);
+            const type = value?.length > 0 ? value[0] as ValueType : null;
+            var d : any = value.length > 0 ? value.slice(1) : Uint8Array.from([]);
+            if (type === ValueType.TYPE_STRING) {
+                d = Bcs.getInstance().de(ValueType.TYPE_VEC_U8, d);
+                d = new TextDecoder().decode(Uint8Array.from(d));
+            } else if (type === ValueType.TYPE_VEC_STRING) {
+                d = Bcs.getInstance().de(ValueType.TYPE_VEC_VEC_U8, d) as [];
+                d = d.map((i:any) => {
+                    return new TextDecoder().decode(Uint8Array.from(i));
+                })
+            } else {
+                d = Bcs.getInstance().de(value[0], d);
+                if (type === ValueType.TYPE_ADDRESS) {
+                    d = '0x' + d;
+                } else if (type === ValueType.TYPE_VEC_ADDRESS) {
+                    d = d.map((v:string) => { return ('0x' + v) } );
+                }
+            };
+            return {object:v?.data?.content?.fields?.id?.id, id:(v?.data?.content?.fields as any)?.name?.fields?.id, 
+                name:(v?.data?.content?.fields as any)?.name?.fields?.key, 
+                data:d, dataType: ValueTypeConvert(type)
+            }
+        });
+        return rep;
+    }
+
+    static DataType2ValueType(data:string) : ValueType | undefined{
+        try {
+            const value = BigInt(data);
+            var t = ValueType.TYPE_U8;
+            if (value <= MAX_U8) {
+            } else if (value <= MAX_U64) {
+                t = ValueType.TYPE_U64;
+            } else if (value <= MAX_U128) {
+                t = ValueType.TYPE_U128;
+            } else if (value <= MAX_U256) {
+                t = ValueType.TYPE_U256;
+            } else {
+                return undefined
+            }
+        } catch (e) {
+            console.log(e)
+        } return undefined
+    }
+
+    static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | 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) {
+            const t = Repository.DataType2ValueType(data as string);
+            if (!t) return undefined;
+            return {type:t, data:Bcs.getInstance().ser(t, data)}
+       } else if (dataType === RepositoryValueType.Address) {
+            if (!IsValidAddress(data as string)) return undefined;
+            return {type:ValueType.TYPE_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, data)}
+       } else if (dataType === RepositoryValueType.Address_Vec) {
+            for(let i = 0; i < (data as string[]).length; ++i) {
+                if (!IsValidAddress((data as string[])[i])) return undefined; 
+            }
+            return {type:ValueType.TYPE_VEC_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_VEC_ADDRESS, data)}
+       } else if (dataType === RepositoryValueType.PositiveNumber_Vec) {
+            let type = ValueType.TYPE_U8;
+            for(let i = 0; i < (data as string[]).length; ++i) {
+                const t = Repository.DataType2ValueType(data as string);
+                if (!t) return undefined;
+                if (t > type) type = t;
+            }
+            if (type === ValueType.TYPE_U8) { 
+                type  = ValueType.TYPE_VEC_U8;
+            } else if (type === ValueType.TYPE_U64) {
+                type = ValueType.TYPE_VEC_U64;
+            } else if (type === ValueType.TYPE_U128) {
+                type = ValueType.TYPE_VEC_U128;
+            } else {
+                type = ValueType.TYPE_VEC_U256;
+            }
+            return {type:type, data:Bcs.getInstance().ser(type, data)}
+       } else if (dataType === RepositoryValueType.String_Vec) {
+            const r = (data as string[]).map((v:string) => {
+                return new TextEncoder().encode(v);
+            })
+            return {type: ValueType.TYPE_VEC_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_VEC_U8, r)}
+       }
+       return undefined
+    }
 }
 

package/src/resource.ts

@@ -36,15 +36,22 @@ export class Resource {
         return r
     }
 
+    launch() {
+        if (!this.object) ERROR(Errors.Fail, 'launch object Invalid');
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('create')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object)]
+        });
+    }
     add(name:string, object:string[])  {
         if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add');
-        if (!object) ERROR(Errors.InvalidParam, 'add')
         if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'add');
 
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
             target:this.protocol.ResourceFn('add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, 'vector<address>')]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name), txb.pure(object, 'vector<address>')]
         });
     }
 
@@ -60,22 +67,22 @@ export class Resource {
         });
     }
 
-    remove(name:string, object?:string[], removeall?:boolean)  {
+    remove(name:string, object:string[], removeall?:boolean)  {
         if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
-        if (!object && !removeall) ERROR(Errors.InvalidParam, 'Resource: remove, BOTH param undefined');
+        if (object.length===0 && !removeall) return;
         
         let txb = this.protocol.CurrentSession();
         if (removeall) {
             txb.moveCall({
                 target:this.protocol.ResourceFn('remove_all')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING)]
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name)]
             });
         } else if(object) {
             if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'Resource: remove');
 
             txb.moveCall({
                 target:this.protocol.ResourceFn('remove')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, 'vector<address>')]
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name), txb.pure(object, 'vector<address>')]
             });
         }
     }
@@ -98,7 +105,7 @@ export class Resource {
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
             target:this.protocol.ResourceFn('rename')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_name, BCS.STRING), txb.pure(new_name, BCS.STRING)]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_name), txb.pure(new_name)]
         }); 
     }
 
@@ -109,10 +116,13 @@ export class Resource {
         if (!IsValidArray(tags, IsValidName)) ERROR(Errors.IsValidArray, 'add_tags');
         if (tags.length > Resource.MAX_TAGS) ERROR(Errors.InvalidParam, 'add_tags');
 
-        let txb = this.protocol.CurrentSession();
+        const txb = this.protocol.CurrentSession();
+        const encode = new TextEncoder();
+
         txb.moveCall({
             target:this.protocol.ResourceFn('tags_add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(nick, BCS.STRING),
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), 
+                txb.pure(nick),
                 txb.pure(tags, 'vector<string>')
             ]
         });

package/src/reward.ts

@@ -1,7 +1,7 @@
 import { TransactionArgument, TransactionBlock, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS} from '@mysten/bcs';
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RewardAddress, Protocol, TxbObject, } from './protocol';
-import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription,  IsValidUint, } from './utils';
+import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription,  IsValidUintLarge, } from './utils';
 import { ERROR, Errors } from './exception';
 import { Resource } from './resource';
 
@@ -41,7 +41,7 @@ export class Reward {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        if (!IsValidUint(time)) {
+        if (!IsValidUintLarge(time)) {
             ERROR(Errors.IsValidUint, 'time')
         }
 
@@ -101,7 +101,7 @@ export class Reward {
     }
 
     expand_time(ms_expand:boolean, time:number, passport?:PassportObject)  {
-        if (!IsValidUint(time)) {
+        if (!IsValidUintLarge(time)) {
             ERROR(Errors.IsValidUint, 'minutes_expand')
         }
 
@@ -125,13 +125,11 @@ export class Reward {
     }
 
     add_guard(gurads:RewardGuardPortions[], passport?:PassportObject)  {
-        if (!gurads) {
-            ERROR(Errors.InvalidParam, 'gurads')
-        }
+        if (gurads.length === 0) return;
 
         let bValid = true;
         gurads.forEach((v) => {
-            if (!IsValidUint(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
+            if (!IsValidUintLarge(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
             if (!Protocol.IsValidObjects([v.guard])) bValid = false;
         })
         if (!bValid) {
@@ -162,11 +160,11 @@ export class Reward {
     }
 
     remove_guard(guards:string[], removeall?:boolean, passport?:PassportObject)  {
-        if (!removeall && !guards) {
-            ERROR(Errors.AllInvalid,  'guards & removeall')
+        if (!removeall && guards.length===0) {
+            return
         }
 
-        if (guards && !IsValidArray(guards, IsValidAddress)) {
+        if (!IsValidArray(guards, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'guards')
         }
 
@@ -333,6 +331,6 @@ export class Reward {
         }
         return '';
     }
-    static MAX_PORTIONS_COUNT = 255;
+    static MAX_PORTIONS_COUNT = 600;
     static MAX_GUARD_COUNT = 16;
 }