wowok 1.2.7 → 1.2.8

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;
 }

package/src/service.ts

@@ -1,6 +1,6 @@
 import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig } from '@mysten/bcs';
 import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, Bcs, array_unique, IsValidTokenType, IsValidDesription, 
-    IsValidAddress, IsValidEndpoint, OptionNone, IsValidUint, IsValidInt, IsValidName, } from './utils'
+    IsValidAddress, IsValidEndpoint, OptionNone, IsValidUintLarge, IsValidInt, IsValidName, } from './utils'
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryObject, MachineObject, ServiceAddress, 
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
     TxbObject} from './protocol';
@@ -113,7 +113,7 @@ export class Service {
         } else {
             s.object = txb.moveCall({
                 target:protocol.ServiceFn('new') as FnCallType,
-                arguments:[txb.pure(description, BCS.STRING), txb.pure(payee_address, BCS.ADDRESS), ep, Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure(description), txb.pure(payee_address, BCS.ADDRESS), ep, Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[pay_token_type],
             })
         }
@@ -211,7 +211,7 @@ export class Service {
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
         }
-        if (!IsValidUint(stock_add)) {
+        if (!IsValidUintLarge(stock_add)) {
             ERROR(Errors.IsValidUint, 'stock_add')
         }
 
@@ -236,7 +236,7 @@ export class Service {
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
         }
-        if (!IsValidUint(stock_reduce)) {
+        if (!IsValidUintLarge(stock_reduce)) {
             ERROR(Errors.IsValidUint, 'stock_reduce')
         }
 
@@ -323,11 +323,10 @@ export class Service {
             })  
         }
     }
-    repository_remove(repository_address?:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!removeall && !repository_address) {
-            ERROR(Errors.AllInvalid,  'removeall & repository_address');
-        }
-        if (repository_address && !IsValidArray(repository_address, IsValidAddress)) {
+    repository_remove(repository_address:string[], removeall?:boolean, passport?:PassportObject) {
+        if (!removeall && repository_address.length===0)  return;
+        
+        if (!IsValidArray(repository_address, IsValidAddress)) {
             ERROR(Errors.IsValidArray,  'repository_address');
         }
 
@@ -366,6 +365,8 @@ export class Service {
     }
 
     add_withdraw_guards(guards:Service_Guard_Percent[], passport?:PassportObject) {
+        if (guards.length === 0) return;
+
         let bValid = true;
         guards.forEach((v) => {
             if (!Protocol.IsValidObjects([v.guard])) bValid  = false;
@@ -394,12 +395,12 @@ export class Service {
             }
         })
     }
-    remove_withdraw_guards(guard_address?:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!removeall && !guard_address) {
-            ERROR(Errors.AllInvalid, 'guard_address & removeall')
+    remove_withdraw_guards(guard_address:string[], removeall?:boolean, passport?:PassportObject) {
+        if (!removeall && guard_address.length===0) {
+            return
         }
 
-        if (guard_address && !IsValidArray(guard_address, IsValidAddress)) {
+        if (!IsValidArray(guard_address, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'guard_address')
         }
 
@@ -437,6 +438,8 @@ export class Service {
         }
     }
     add_refund_guards(guards:Service_Guard_Percent[], passport?:PassportObject) {
+        if (guards.length === 0) return;
+
         let bValid = true;
         guards.forEach((v) => {
             if (!Protocol.IsValidObjects([v.guard])) bValid = false;
@@ -465,11 +468,9 @@ export class Service {
             }
         })
     }
-    remove_refund_guards(guard_address?:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!guard_address && !removeall) {
-            ERROR(Errors.AllInvalid, 'guard_address & removeall');
-        }
-        if (guard_address && !IsValidArray(guard_address, IsValidAddress)) {
+    remove_refund_guards(guard_address:string[], removeall?:boolean, passport?:PassportObject) {
+        if (guard_address.length===0 && !removeall) return ;
+        if (!IsValidArray(guard_address, IsValidAddress)) {
             ERROR(Errors.InvalidParam, 'guard_address')
         }
 
@@ -512,22 +513,24 @@ export class Service {
         sales.forEach((v) => {
             if (!IsValidName(v.item)) bValid = false;
             if (!IsValidInt(v.price)) bValid = false;
-            if (!IsValidUint(v.stock)) bValid = false;
+            if (!IsValidUintLarge(v.stock)) bValid = false;
             if (names.includes(v.item)) bValid = false;
             names.push(v.item)
         })
         return bValid
     }
 
-    add_sale(sales:Service_Sale[], bExistAssert:boolean=false, passport?:PassportObject) {
-        if (!sales || !this.is_valid_sale(sales)) {
-            ERROR(Errors.InvalidParam, 'add_sale')
+    add_sales(sales:Service_Sale[], bExistAssert:boolean=false, passport?:PassportObject) {
+        if (sales.length === 0) return;
+
+        if (!this.is_valid_sale(sales)) {
+            ERROR(Errors.InvalidParam, 'add_sales')
         }
         
         let names: string[]  = []; let price: number[] = []; let stock: number[] = []; let endpoint: string[] = [];
         sales.forEach((s) => {
             if (s.endpoint && !IsValidEndpoint(s.endpoint)) {
-                ERROR(Errors.IsValidEndpoint, 'add_sale')
+                ERROR(Errors.IsValidEndpoint, 'add_sales')
             }
             names.push(s.item); price.push(s.price); stock.push(s.stock); endpoint.push(s.endpoint ?? '')
         })
@@ -554,12 +557,11 @@ export class Service {
             })
         }
     }
-    remove_sales(sales?:string[], passport?:PassportObject) {
-        if (!sales) {
-            ERROR(Errors.AllInvalid, 'sales & removeall')
-        }
-        if (sales && !IsValidArray(sales, IsValidName)) {
-            ERROR(Errors.IsValidArray, 'sales')
+    remove_sales(sales:string[], passport?:PassportObject) {
+        if (sales.length === 0) return;
+
+        if (!IsValidArray(sales, IsValidName)) {
+            ERROR(Errors.IsValidArray, 'remove_sales')
         }
 
         let txb = this.protocol.CurrentSession();
@@ -588,11 +590,11 @@ export class Service {
         let bValid = true;
         discount_dispatch.forEach((v) => {
             if (!IsValidAddress(v.receiver)) bValid = false;
-            if (!IsValidUint(v.count) || v.count > Service.MAX_DISCOUNT_COUNT_ONCE) bValid = false;
+            if (!IsValidUintLarge(v.count) || v.count > Service.MAX_DISCOUNT_COUNT_ONCE) bValid = false;
             if (!IsValidName_AllowEmpty(v.discount.name)) bValid = false;
             if (v.discount.type == Service_Discount_Type.ratio && !IsValidPercent(v.discount.off)) bValid = false;
-            if (!IsValidUint(v.discount.duration_minutes)) bValid = false;
-            if (v.discount?.time_start && !IsValidUint(v.discount.time_start)) bValid = false;
+            if (!IsValidUintLarge(v.discount.duration_minutes)) bValid = false;
+            if (v.discount?.time_start && !IsValidUintLarge(v.discount.time_start)) bValid = false;
             if (v.discount?.price_greater && !IsValidInt(v.discount.price_greater))  bValid = false;
         })
         if (!bValid) {
@@ -932,7 +934,7 @@ export class Service {
         buy_items.forEach((v) => {
             if (!IsValidName(v.item)) bValid = false;
             if (!IsValidInt(v.max_price)) bValid = false;
-            if (!IsValidUint(v.count)) bValid = false;
+            if (!IsValidUintLarge(v.count)) bValid = false;
             if (names.includes(v.item)) bValid = false;
             names.push(v.item)
         })

package/src/utils.ts

@@ -1,10 +1,11 @@
 import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, BcsReader } from '@mysten/bcs';
 import { TransactionBlock, Inputs, TransactionResult, TransactionArgument } from '@mysten/sui.js/transactions';
+import { SuiObjectResponse, DynamicFieldPage } from '@mysten/sui.js/client';
 import { ERROR, Errors } from './exception';
 import { isValidSuiAddress, isValidSuiObjectId } from '@mysten/sui.js/utils'
-import { RepositoryValueType, ValueType } from './protocol'
+import { RepositoryValueType, ValueType, Protocol } from './protocol'
 
-export const MAX_U8 = BigInt('256');
+export const MAX_U8 = BigInt('255');
 export const MAX_U64 = BigInt('18446744073709551615');
 export const MAX_U128 = BigInt('340282366920938463463374607431768211455');
 export const MAX_U256 = BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935');
@@ -30,36 +31,7 @@ export const ValueTypeConvert = (type:ValueType | null | undefined) : Repository
     return -1;
 }
 
-export const ResolveRepositoryData = (dataType:RepositoryValueType, data:Uint8Array) : {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) {
-        try {
-            const value = BigInt(data.toString());
-            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
-        }
-        return {type:t, data:Bcs.getInstance().ser(t, data)}
-   } else if (dataType === RepositoryValueType.Address) {
-        return {type:ValueType.TYPE_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, data)}
-   } 
-   //@ todo vector....
-   return undefined
-}
-
-export const readOption = (arr: number[], de:ValueType) : {bNone:boolean, value:any}=> {
+export const readOption = (arr: number[], de:ValueType) : {bNone:boolean, value:any} => {
     let o = arr.splice(0, 1);
     if (o[0] == 1) { // true
         return {bNone:false,  value:Bcs.getInstance().de(de, Uint8Array.from(arr))};
@@ -209,7 +181,15 @@ export class Bcs {
         return Bcs._instance;
      }
 
-    ser(type:ValueType, data:Uint8Array | any) : Uint8Array {
+    ser_option_u32(data:Uint8Array | any) : Uint8Array {
+        return this.bcs.ser('Option<u32>', {'some': data}).toBytes();
+    }
+
+    ser(type:ValueType | string, data:Uint8Array | any) : Uint8Array {
+        if (typeof(type) === 'string') {
+            return this.bcs.ser(type, data).toBytes();
+        }
+
         switch(type) {
             case ValueType.TYPE_BOOL:
                 return this.bcs.ser(BCS.BOOL, data).toBytes();
@@ -397,6 +377,15 @@ export const IsValidAddress = (addr:string) : boolean => {
     }
     return true
 }
+export const IsValidUintLarge = (value:string | number) : boolean => {
+    try {
+        const v = BigInt(value);
+        if (v <= MAX_U256) {
+            return true   
+        }
+    } catch (e) {
+    }; return false
+}
 export const IsValidTokenType = (argType: string) : boolean => { 
     if (!argType || argType.length === 0) {
         return false; 
@@ -420,12 +409,6 @@ export const IsValidArgType = (argType: string) : boolean => {
     } 
     return true;
 }
-export const IsValidUint = (value: number | string) : boolean => { 
-    if (typeof(value) === 'string') {
-        value = parseInt(value as string);
-    }
-    return Number.isSafeInteger(value) && value > 0 
-}
 export const IsValidInt = (value: number | string) : boolean => { 
     if (typeof(value) === 'string') {
         value = parseInt(value as string);
@@ -468,7 +451,7 @@ export const ResolveBalance = (balance:string, decimals:number) : string => {
         let end = balance.slice(Math.abs(pos));
         return start + '.' + end;
     } else {
-        return '.' + balance.padStart(pos, '0');
+        return '.' + balance.padStart(decimals, '0');
     }
 }
 
@@ -525,4 +508,47 @@ export function isValidHttpUrl(url:string) : boolean {
     }
   
     return r.protocol === "http:" || r.protocol === "https:" || r.protocol === 'ipfs:';
-}
+}
+
+export interface query_object_param {
+    id:string;
+    onBegin?:(id:string)=>void;
+    onObjectRes?:(id:string, res:SuiObjectResponse)=>void;
+    onDynamicRes?:(id:string, res:DynamicFieldPage)=>void;
+    onFieldsRes?:(id:string, fields_res:SuiObjectResponse[])=>void;
+    onObjectErr?:(id:string, err:any)=>void;
+    onDynamicErr?:(id:string, err:any)=>void;
+    onFieldsErr?:(id:string, err:any)=>void;
+}
+
+export const query_object = (param:query_object_param) => {
+    if (param.id) {
+      if(param?.onBegin) param.onBegin(param.id);
+      Protocol.Client().getObject({id:param.id, options:{showContent:true, showType:true}}).then((res) => {
+        if (res.error) {
+            if(param?.onObjectErr) param.onObjectErr(param.id, res.error);
+        } else {
+            if(param?.onObjectRes) param.onObjectRes(param.id, res);
+        }
+      }).catch((err) => {
+        console.log(err)
+        if (param?.onObjectErr) param.onObjectErr(param.id, err);
+      });
+
+      Protocol.Client().getDynamicFields({parentId:param.id}).then((res) => {
+        if (param?.onDynamicRes) param.onDynamicRes(param.id, res);
+        
+        if (res.data.length > 0) {
+          Protocol.Client().multiGetObjects({ids:res.data.map(v => v.objectId), options:{showContent:true}}).then((fields) => {
+            if (param?.onFieldsRes) param.onFieldsRes(param.id, fields);
+          }).catch((err) => {
+            console.log(err)
+            if (param?.onFieldsErr) param.onFieldsErr(param.id, err);
+          })          
+        } 
+      }).catch((err) => {
+        console.log(err)
+        if (param?.onDynamicErr) param.onDynamicErr(param.id, err);
+      })
+    }
+  }