wowok 1.2.5 → 1.2.8

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, IsValidArgType, IsValidDesription, 
-    IsValidAddress, IsValidEndpoint, OptionNone, IsValidUint, IsValidInt, IsValidName, } from './utils'
+import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, Bcs, array_unique, IsValidTokenType, IsValidDesription, 
+    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';
@@ -15,6 +15,7 @@ export type Service_Sale = {
     item:string;
     price:number;
     stock:number;
+    endpoint?:string;
 }
 export enum Service_Discount_Type {
     ratio = 0, // -off%
@@ -63,7 +64,7 @@ export class Service {
     protected object : TxbObject;
     protected protocol;
 
-    static token2coin = (token:string) => { return '0x2::coin::Coin<' + token + '>'};
+    //static token2coin = (token:string) => { return '0x2::coin::Coin<' + token + '>'};
 
     get_pay_type() {  return this.pay_token_type }
     get_object() { return this.object }
@@ -74,7 +75,7 @@ export class Service {
         this.object = ''
     }
     static From(protocol: Protocol, token_type:string, permission:PermissionObject, object:TxbObject) : Service {
-        let s = new Service(protocol, this.token2coin(token_type), permission);
+        let s = new Service(protocol, token_type, permission);
         s.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
         return s
     }
@@ -83,8 +84,8 @@ export class Service {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects)
         }
-        if (!IsValidArgType(token_type)) {
-            ERROR(Errors.IsValidArgType, 'New: pay_token_type') 
+        if (!IsValidTokenType(token_type)) {
+            ERROR(Errors.IsValidTokenType, 'New: pay_token_type') 
         }
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
@@ -97,7 +98,7 @@ export class Service {
             ERROR(Errors.IsValidEndpoint)
         }
 
-        let pay_token_type = this.token2coin(token_type);
+        let pay_token_type = token_type;
         let s = new Service(protocol, pay_token_type, permission);
         let txb = protocol.CurrentSession();
         let ep = endpoint? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_STRING, endpoint)) : OptionNone(txb);
@@ -112,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],
             })
         }
@@ -210,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')
         }
 
@@ -235,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')
         }
 
@@ -256,6 +257,32 @@ export class Service {
             })
         }
     }
+    set_sale_endpoint(item:string, endpoint?:string, bNotFoundAssert:boolean=true, passport?:PassportObject) {
+        if (!IsValidName(item)) {
+            ERROR(Errors.IsValidName, 'set_sale_endpoint')
+        }
+        if (endpoint && !IsValidEndpoint(endpoint)) {
+            ERROR(Errors.IsValidEndpoint, 'set_sale_endpoint')
+        }
+        let txb = this.protocol.CurrentSession();
+        let ep = endpoint? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_STRING, endpoint)) : OptionNone(txb);
+        if (passport) {
+            txb.moveCall({
+                target:this.protocol.ServiceFn('sale_endpoint_set_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(item), ep, 
+                    txb.pure(bNotFoundAssert, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            txb.moveCall({
+                target:this.protocol.ServiceFn('sale_endpoint_set') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(item), ep, 
+                    txb.pure(bNotFoundAssert, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }        
+    }
+
     set_payee(payee:string, passport?:PassportObject)  {
         if (!IsValidAddress(payee)) {
             ERROR(Errors.IsValidAddress, 'payee');
@@ -293,14 +320,13 @@ export class Service {
                 target:this.protocol.ServiceFn('repository_add') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, repository), Protocol.TXB_OBJECT(txb, this.permission)],
                 typeArguments:[this.pay_token_type]
-            })
+            })  
         }
     }
-    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');
         }
 
@@ -339,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;
@@ -367,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')
         }
 
@@ -410,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;
@@ -438,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')
         }
 
@@ -485,21 +513,26 @@ 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[], passport?:PassportObject) {
-        if (!sales || !this.is_valid_sale(sales)) {
-            ERROR(Errors.InvalidParam, 'Service_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 names: string[]  = []; let price: number[] = []; let stock: number[] = []; let endpoint: string[] = [];
         sales.forEach((s) => {
-            names.push(s.item); price.push(s.price); stock.push(s.stock);
+            if (s.endpoint && !IsValidEndpoint(s.endpoint)) {
+                ERROR(Errors.IsValidEndpoint, 'add_sales')
+            }
+            names.push(s.item); price.push(s.price); stock.push(s.stock); endpoint.push(s.endpoint ?? '')
         })
 
         let txb = this.protocol.CurrentSession();
@@ -507,7 +540,8 @@ export class Service {
             txb.moveCall({
                 target:this.protocol.ServiceFn('sales_add_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, names)), 
-                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, endpoint)), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_BOOL, bExistAssert)),
                     Protocol.TXB_OBJECT(txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
@@ -515,52 +549,36 @@ export class Service {
             txb.moveCall({
                 target:this.protocol.ServiceFn('sales_add') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, names)), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, endpoint)),
                     txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_BOOL, bExistAssert)),
                     Protocol.TXB_OBJECT(txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         }
-        
     }
-    remove_sales(sales?:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!removeall && !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();
         if (passport) {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.ServiceFn('sales_remove_all_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)],
-                    typeArguments:[this.pay_token_type]
-                })    
-            } else {
-                txb.moveCall({
-                    target:this.protocol.ServiceFn('sales_remove_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)],
-                    typeArguments:[this.pay_token_type]
-                })            
-            }
+            txb.moveCall({
+                target:this.protocol.ServiceFn('sales_remove_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })            
         } else {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.ServiceFn('sales_remove_all') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)],
-                    typeArguments:[this.pay_token_type]
-                })      
-            } else {
-                txb.moveCall({
-                    target:this.protocol.ServiceFn('sales_remove') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)],
-                    typeArguments:[this.pay_token_type]
-                })            
-            }
+            txb.moveCall({
+                target:this.protocol.ServiceFn('sales_remove') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })            
         }     
     }
 
@@ -572,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) {
@@ -766,8 +784,6 @@ export class Service {
         }
 
         let req = array_unique(customer_required) as string[];
-        console.log(req)
-        console.log(this.pay_token_type)
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
@@ -918,12 +934,12 @@ 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)
         })
         if (!bValid) {
-            ERROR(Errors.InvalidParam, 'buy_items')
+            ERROR(Errors.InvalidParam, 'buy_items 2')
         }
 
         let name:string[] = []; let price:number[] = [];    let stock:number[] = []; let order;
@@ -1018,4 +1034,23 @@ export class Service {
     static MAX_DISCOUNT_RECEIVER_COUNT = 20;
     static MAX_GUARD_COUNT = 16;
     static MAX_REPOSITORY_COUNT = 16;
+    
+    static parseObjectType = (chain_type:string | undefined | null) : string =>  {
+        if (chain_type) {
+            const s = 'service::Service<'
+            const i = chain_type.indexOf(s);
+            if (i > 0) {
+                return chain_type.slice(i + s.length, chain_type.length-1);
+            }
+        }
+        return '';
+    }
+    static endpoint = (service_endpoint:string, item_endpoint:string, item_name:string) => {
+        if (item_endpoint) {
+            return item_endpoint
+        } else if  (service_endpoint) {
+            return service_endpoint + '/sales/' + encodeURI(item_name);
+        }
+    }
+
 }

package/src/utils.ts

@@ -1,11 +1,37 @@
-import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, StructTypeDefinition } from '@mysten/bcs';
+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 { ValueType } from './protocol'
+import { RepositoryValueType, ValueType, Protocol } from './protocol'
+
+export const MAX_U8 = BigInt('255');
+export const MAX_U64 = BigInt('18446744073709551615');
+export const MAX_U128 = BigInt('340282366920938463463374607431768211455');
+export const MAX_U256 = BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935');
 
 export const OPTION_NONE = 0;
-export const readOption = (arr: number[], de:ValueType) : {bNone:boolean, value:any}=> {
+
+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) {
+            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) {
+            return RepositoryValueType.PositiveNumber_Vec
+    } else if (type === ValueType.TYPE_ADDRESS) {
+        return RepositoryValueType.Address
+    } else if (type === ValueType.TYPE_VEC_ADDRESS) {
+        return RepositoryValueType.Address_Vec
+    } else if (type === ValueType.TYPE_STRING) {
+        return RepositoryValueType.String
+    } else if (type === ValueType.TYPE_VEC_STRING) {
+        return RepositoryValueType.String_Vec
+    } 
+    return -1;
+}
+
+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))};
@@ -133,6 +159,20 @@ export class Bcs {
             'none': null,
             'some': 'T',
         });
+        this.bcs.registerStructType('EntStruct', {
+            'avatar': 'vector<u8>',
+            'resource': "Option<address>",
+            'like': BCS.U32,
+            'dislike': BCS.U32,
+        })
+        this.bcs.registerStructType('PersonalInfo', {
+            'name': 'vector<u8>',
+            'description': 'vector<u8>',
+            'avatar': BCS.STRING,
+            'twitter': BCS.STRING,
+            'discord': BCS.STRING,
+            'homepage': BCS.STRING,
+        })
     }
     static getInstance() : Bcs { 
         if (!Bcs._instance) {
@@ -140,7 +180,16 @@ 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();
@@ -201,6 +250,7 @@ export class Bcs {
             case ValueType.TYPE_U64:
                 return this.bcs.de(BCS.U64, data);
             case ValueType.TYPE_U8:
+                console.log(data)
                 return this.bcs.de(BCS.U8, data);
             case ValueType.TYPE_VEC_U8:
                 return this.bcs.de('vector<u8>', data);
@@ -242,6 +292,30 @@ export class Bcs {
                 ERROR(Errors.bcsTypeInvalid, 'de');
         }
     }
+
+    de_ent(data:Uint8Array) : any {
+        const struct_vec = this.bcs.de('vector<u8>', data);
+        return this.bcs.de('EntStruct', Uint8Array.from(struct_vec));
+/*        const reader = new BcsReader(data);
+        const total_len = reader.readULEB();
+        console.log(avatar_len)
+        const avatar = reader.readBytes(avatar_len);
+        console.log(avatar)
+        const option_resource = reader.read8();
+        var resource = '';
+        if (option_resource != 0) {
+            resource = reader.read256();
+        }
+        const like = reader.read32();
+        const dislike = reader.read32();
+        return {avatar:avatar, resource:resource, like:like, dislike:dislike}*/
+    }    
+    de_entInfo(data:Uint8Array) : any {
+        let r = this.bcs.de('PersonalInfo', data);
+        r.name = new TextDecoder().decode(Uint8Array.from(r.name));
+        r.description = new TextDecoder().decode(Uint8Array.from(r.description));
+        return r
+    }        
 }
 
 export function stringToUint8Array(str:string) : Uint8Array {
@@ -264,7 +338,6 @@ export function numToUint8Array(num:number) : Uint8Array {
     return new Uint8Array(a)
 } 
 
-// 判断是否为数组
 export const isArr = (origin: any): boolean => {
     let str = '[object Array]'
     return Object.prototype.toString.call(origin) == str ? true : false
@@ -304,7 +377,16 @@ export const IsValidAddress = (addr:string) : boolean => {
     }
     return true
 }
-export const IsValidArgType = (argType: string) : boolean => { 
+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; 
     }
@@ -312,17 +394,20 @@ export const IsValidArgType = (argType: string) : boolean => {
     if (arr.length !== 3) {
         return false;
     } 
-    if (!IsValidAddress(arr[0]) || arr[1].length === 0 || arr[2].length === 0) {
+    if ((!IsValidAddress(arr[0]) && arr[0] != '0x2') || arr[1].length === 0 || arr[2].length === 0) {
         return false;
     }
     return true;
 }
-
-export const IsValidUint = (value: number | string) : boolean => { 
-    if (typeof(value) === 'string') {
-        value = parseInt(value as string);
+export const IsValidArgType = (argType: string) : boolean => { 
+    if (!argType || argType.length === 0) {
+        return false; 
     }
-    return Number.isSafeInteger(value) && value > 0 
+    let arr = argType.split('::');
+    if (arr.length < 3) {
+        return false;
+    } 
+    return true;
 }
 export const IsValidInt = (value: number | string) : boolean => { 
     if (typeof(value) === 'string') {
@@ -337,13 +422,37 @@ export const IsValidPercent = (value: number | string) : boolean => {
     return Number.isSafeInteger(value) && value > 0 && value <= 100 
 }
 export const IsValidArray = (arr: any[], validFunc:any) : boolean => {
-    let bValid = true;
-    arr.forEach((v) => {
-        if (!validFunc(v)) {
-            bValid = false; 
+    for (let i = 0; i < arr.length; ++i) {
+        if (!validFunc(arr[i])) {
+            return false
         }
-    })
-    return bValid;
+    }
+    return true
+}
+
+export const ResolveU64 = (value:bigint) : bigint => {
+    const max = MAX_U64;
+    if (value > max) {
+        return max;
+    } else {
+        return value
+    }
+}
+
+export const ResolveBalance = (balance:string, decimals:number) : string => {
+    if (!balance) return ''
+    if (balance === '0') return '0'
+    if (decimals <= 0) return balance;
+    var pos = decimals - balance.length;
+    if (pos === 0) {
+       return '.' + balance;
+    } else if (pos < 0) {
+        let start = balance.slice(0, Math.abs(pos));
+        let end = balance.slice(Math.abs(pos));
+        return start + '.' + end;
+    } else {
+        return '.' + balance.padStart(decimals, '0');
+    }
 }
 
 export const OptionNone = (txb:TransactionBlock) : TransactionArgument => { return txb.pure([], BCS.U8) };
@@ -355,9 +464,9 @@ export type ArgType = {
 }
 export const ParseType = (type:string) : ArgType => {
     if (type) {
-        const COIN = '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<';
+        const COIN = '0x2::coin::Coin<';
         let i = type.indexOf(COIN);
-        if (i > 0) {
+        if (i >= 0) {
             let coin = type.slice(i+COIN.length, type.length-1);
             if (coin.indexOf('<') === -1) {
                 while (coin[coin.length-1] == '>') {
@@ -398,5 +507,48 @@ export function isValidHttpUrl(url:string) : boolean {
       return false;  
     }
   
-    return r.protocol === "http:" || r.protocol === "https:";
-}
+    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);
+      })
+    }
+  }