wowok 1.4.23 → 1.4.27

package/src/reward.ts

@@ -1,6 +1,6 @@
 import { TransactionArgument, Transaction as TransactionBlock, type TransactionResult, } from '@mysten/sui/transactions';
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RewardAddress, Protocol, TxbObject, } from './protocol';
-import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription,  IsValidUintLarge, } from './utils';
+import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription, IsValidU64, parseObjectType} from './utils';
 import { ERROR, Errors } from './exception';
 
 export type CoinReward = TransactionResult;
@@ -39,7 +39,7 @@ export class Reward {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        if (!IsValidUintLarge(time)) {
+        if (!IsValidU64(time)) {
             ERROR(Errors.IsValidUint, 'time')
         }
 
@@ -96,7 +96,7 @@ export class Reward {
     }
 
     expand_time(ms_expand:boolean, time:number, passport?:PassportObject)  {
-        if (!IsValidUintLarge(time)) {
+        if (!IsValidU64(time)) {
             ERROR(Errors.IsValidUint, 'minutes_expand')
         }
         
@@ -117,20 +117,20 @@ export class Reward {
         }
     }
 
-    add_guard(gurads:RewardGuardPortions[], passport?:PassportObject)  {
-        if (gurads.length === 0) return;
+    add_guard(guards:RewardGuardPortions[], passport?:PassportObject)  {
+        if (guards.length === 0) return;
 
         let bValid = true;
-        gurads.forEach((v) => {
-            if (!IsValidUintLarge(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
+        guards.forEach((v) => {
+            if (!IsValidU64(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
             if (!Protocol.IsValidObjects([v.guard])) bValid = false;
         })
         if (!bValid) {
-            ERROR(Errors.InvalidParam, 'gurads')
+            ERROR(Errors.InvalidParam, 'guards')
         }
 
         if (passport) {
-            gurads.forEach((guard) => 
+            guards.forEach((guard) => 
                 this.txb.moveCall({
                     target:Protocol.Instance().RewardFn('guard_add_with_passport') as FnCallType,
                     arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
@@ -140,7 +140,7 @@ export class Reward {
                 })
             )
         } else {
-            gurads.forEach((guard) => 
+            guards.forEach((guard) => 
                 this.txb.moveCall({
                     target:Protocol.Instance().RewardFn('guard_add') as FnCallType,
                     arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, guard.guard), 
@@ -277,7 +277,6 @@ export class Reward {
     }
 
     allow_claim(bAllowClaim: boolean, passport?:PassportObject) {
-        
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().RewardFn('allow_claim_with_passport') as FnCallType,
@@ -298,7 +297,6 @@ export class Reward {
         if (!Protocol.IsValidObjects([new_permission])) {
             ERROR(Errors.IsValidObjects)
         }
-
         
         this.txb.moveCall({
             target:Protocol.Instance().RewardFn('permission_set') as FnCallType,
@@ -308,15 +306,7 @@ export class Reward {
         this.permission = new_permission
     }
     static parseObjectType = (chain_type:string) : string =>  {
-        if (chain_type) {
-            const s = 'reward::Reward<'
-            const i = chain_type.indexOf(s);
-            if (i > 0) {
-                let r = chain_type.slice(i + s.length, chain_type.length-1);
-                return r
-            }
-        }
-        return '';
+        return parseObjectType(chain_type, 'reward::Reward<')
     }
     static MAX_PORTIONS_COUNT = 600;
     static MAX_GUARD_COUNT = 16;

package/src/service.ts

@@ -1,4 +1,4 @@
-import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, Bcs, array_unique, IsValidTokenType, IsValidDesription, 
+import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, parseObjectType, array_unique, IsValidTokenType, IsValidDesription, 
     IsValidAddress, IsValidEndpoint, IsValidU64, } from './utils'
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryObject, MachineObject, ServiceAddress, 
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
@@ -1031,25 +1031,11 @@ export class Service {
     }
 
     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 '';
+        return parseObjectType(chain_type, 'service::Service<')
     }
 
     static parseOrderObjectType = (chain_type:string | undefined | null) : string =>  {
-        if (chain_type) {
-            const s = 'order::Order<'
-            const i = chain_type.indexOf(s);
-            if (i > 0) {
-                return chain_type.slice(i + s.length, chain_type.length-1);
-            }
-        }
-        return '';
+        return parseObjectType(chain_type, 'order::Order<')
     }
 
     static endpoint = (service_endpoint:string, item_endpoint:string, item_name:string) => {
@@ -1062,7 +1048,7 @@ export class Service {
 
     static DiscountObjects = (owner:string, handleDiscountObject:handleDiscountObject) => {
         Protocol.Client().getOwnedObjects({owner:owner, 
-            filter:{MoveModule:{module:'order', package:Protocol.Instance().Package()}}, 
+            filter:{MoveModule:{module:'order', package:Protocol.Instance().Package('wowok')}}, 
             options:{showContent:true, showType:true}}).then((res) => {
             handleDiscountObject(owner, res.data.map((v)=>v.data));
         }).catch((e) => {

package/src/treasury.ts

@@ -1,8 +1,28 @@
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { FnCallType, Protocol, PassportObject, PermissionObject, DemandAddress, TxbObject, CoinObject} from './protocol';
-import { IsValidDesription, IsValidU64, IsValidAddress, IsValidArgType, } from './utils'
+import { FnCallType, Protocol, PassportObject, PermissionObject, TreasuryAddress, TxbObject, CoinObject, PaymentObject,
+    ReceivedObject } from './protocol';
+import { IsValidDesription, IsValidU64, IsValidAddress, IsValidArgType, IsValidArray, parseObjectType} from './utils'
 import { Errors, ERROR}  from './exception'
 
+export interface DepositParam {
+    coin: CoinObject,
+    index: bigint,
+    remark: string,
+    for_object?: string,
+    for_guard?: string,
+}
+
+export interface WithdrawItem {
+    address: string,
+    amount: bigint,
+}
+export interface WithdrawParam {
+    items: WithdrawItem[],
+    index: bigint,
+    remark: string,
+    for_object?: string,
+    for_guard?: string,
+}
 export class Treasury {
     protected token_type;
     protected permission ;
@@ -53,7 +73,7 @@ export class Treasury {
         return d
     }
 
-    launch() : DemandAddress {
+    launch() : TreasuryAddress {
         return this.txb.moveCall({
             target:Protocol.Instance().TreasuryFn('create') as FnCallType,
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object)],
@@ -69,125 +89,176 @@ export class Treasury {
         }) 
     }
     
-    set_free_deposits(bFreeDeposit:boolean, passport?:PassportObject)  {
+    set_free_deposit(bFreeDeposit:boolean, passport?:PassportObject)  {
         if (passport) {
             this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('free_deposits_set_with_passport') as FnCallType,
+                target:Protocol.Instance().TreasuryFn('free_deposit_set_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
                     this.txb.pure.bool(bFreeDeposit), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
             })
         } else {
             this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('free_deposits_set') as FnCallType,
+                target:Protocol.Instance().TreasuryFn('free_deposit_set') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(bFreeDeposit), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
             })            
         }
     }
     
-    deposit(coin:CoinObject, tips:string, for_object?:string, index?:number, from_object?:string, passport?:PassportObject) :TxbObject {
-        if (!Protocol.IsValidObjects([coin])) {
-            ERROR(Errors.IsValidObjects, 'deposit.coin')
+    deposit(param:DepositParam, bFreeDeposit:boolean=false, passport?:PassportObject) :TxbObject {
+        if (!Protocol.IsValidObjects([param.coin])) {
+            ERROR(Errors.IsValidObjects, 'deposit.param.coin')
         }
-        if (!IsValidDesription(tips)) {
-            ERROR(Errors.IsValidDesription, 'deposit.tips')
+        if (!IsValidDesription(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'deposit.param.remark')
         }
-        if (for_object && !IsValidAddress(for_object)) {
-            ERROR(Errors.IsValidAddress, 'deposit.tips')
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'deposit.param.for_object')
         }
-        if (from_object && !IsValidAddress(from_object)) {
-            ERROR(Errors.IsValidAddress, 'deposit.from_object')
+        if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+            ERROR(Errors.IsValidAddress, 'deposit.param.for_guard')
         }
-        if (index !== undefined && !IsValidU64(index)) {
-            ERROR(Errors.InvalidParam, 'deposit.index')
+        if (param.index !== undefined && !IsValidU64(param.index)) {
+            ERROR(Errors.InvalidParam, 'deposit.param.index')
         }
-        const for_obj = this.txb.pure.option('address', for_object ?? undefined);
-        const idx = this.txb.pure.option('u64', index ?? undefined);
-        const from_obj = this.txb.pure.option('address', from_object ?? undefined);
+
+        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
 
+        if (bFreeDeposit) {
+            if (param.for_guard) {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('free_deposit_forGuard') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(param.for_guard), this.txb.object(clock)],
+                    typeArguments:[this.token_type],
+                })  
+            } else {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('free_deposit') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(clock)],
+                    typeArguments:[this.token_type],
+                })  
+            }
+        } else {
+            if (passport) {
+                if (param.for_guard) {
+                    return this.txb.moveCall({
+                        target:Protocol.Instance().TreasuryFn('deposit_forGuard_with_passport') as FnCallType,
+                        arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                            this.txb.pure.string(param.remark), for_obj, this.txb.object(param.for_guard), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                        typeArguments:[this.token_type],
+                    })  
+                } else {
+                    return this.txb.moveCall({
+                        target:Protocol.Instance().TreasuryFn('deposit_with_passport') as FnCallType,
+                        arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                            this.txb.pure.string(param.remark), for_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                        typeArguments:[this.token_type],
+                    })  
+                }
+            } else {
+                if (param.for_guard) {
+                    return this.txb.moveCall({
+                        target:Protocol.Instance().TreasuryFn('deposit_forGuard') as FnCallType,
+                        arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                            this.txb.pure.string(param.remark), for_obj, this.txb.object(param.for_guard), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                        typeArguments:[this.token_type],
+                    })  
+                } else {
+                    return this.txb.moveCall({
+                        target:Protocol.Instance().TreasuryFn('deposit') as FnCallType,
+                        arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, param.coin), this.txb.pure.u64(param.index),
+                            this.txb.pure.string(param.remark), for_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                        typeArguments:[this.token_type],
+                    })  
+                }
+            }
+        }
+    }
+
+    receive(payment:PaymentObject, received:ReceivedObject, passport?:PassportObject)  {
+        if (!Protocol.IsValidObjects([payment, received])) {
+            ERROR(Errors.IsValidArray, 'receive.payment&received');
+        }
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
             return this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('deposit_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, coin), 
-                    this.txb.pure.string(tips), for_obj, idx, from_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                target:Protocol.Instance().TreasuryFn('receive_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(received), this.txb.object(payment), 
+                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
             })
         } else {
             return this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('deposit') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, coin), 
-                    this.txb.pure.string(tips), for_obj, idx, from_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                target:Protocol.Instance().TreasuryFn('receive') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(received), this.txb.object(payment), 
+                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
-            })  
-        }
-    }
-
-    free_deposit(coin:CoinObject, tips:string, for_object?:string, index?:number, from_object?:string) : TxbObject  {
-        if (!Protocol.IsValidObjects([coin])) {
-            ERROR(Errors.IsValidObjects, 'free_deposit.coin')
-        }
-        if (!IsValidDesription(tips)) {
-            ERROR(Errors.IsValidDesription, 'free_deposit.tips')
-        }
-        if (for_object && !IsValidAddress(for_object)) {
-            ERROR(Errors.IsValidAddress, 'free_deposit.for_object')
-        }
-        if (from_object && !IsValidAddress(from_object)) {
-            ERROR(Errors.IsValidAddress, 'free_deposit.from_object')
-        }
-        if (index !== undefined && !IsValidU64(index)) {
-            ERROR(Errors.InvalidParam, 'free_deposit.index')
+            })
         }
-        const for_obj = this.txb.pure.option('address', for_object ?? undefined);
-        const idx = this.txb.pure.option('u64', index ?? undefined);
-        const from_obj = this.txb.pure.option('address', from_object ?? undefined);
-        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
-
-        return this.txb.moveCall({
-            target:Protocol.Instance().TreasuryFn('deposit2') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, coin), 
-                this.txb.pure.string(tips), for_obj, idx, from_obj, this.txb.object(clock)],
-            typeArguments:[this.token_type],
-        })  
     }
     
-    withdraw(amount:number, tips:string, for_object?:string, index?:number, to_object?:string, passport?:PassportObject) : CoinObject {
-        if (!IsValidU64(amount)) {
-            ERROR(Errors.IsValidObjects, 'withdraw.amount')
+    withdraw(param:WithdrawParam, passport?:PassportObject)  {
+        if (param.items.length === 0) return undefined;
+        if (!IsValidArray(param.items, (item:WithdrawItem) => IsValidU64(item.amount) && IsValidAddress(item.address))) {
+            ERROR(Errors.IsValidArray, 'withdraw.param.items')
         }
-        if (!IsValidDesription(tips)) {
-            ERROR(Errors.IsValidDesription, 'withdraw.tips')
+        if (!IsValidDesription(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'withdraw.param.remark')
         }
-        if (for_object && !IsValidAddress(for_object)) {
-            ERROR(Errors.IsValidAddress, 'withdraw.for_object')
+        if (!IsValidU64(param.index)) {
+            ERROR(Errors.IsValidU64, 'withdraw.param.index')
         }
-        if (to_object && !IsValidAddress(to_object)) {
-            ERROR(Errors.IsValidAddress, 'withdraw.to_object')
+        if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.for_guard')
         }
-        if (index !== undefined && !IsValidU64(index)) {
-            ERROR(Errors.InvalidParam, 'withdraw.index')
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.for_object')
         }
-        const for_obj = this.txb.pure.option('address', for_object ?? undefined);
-        const idx = this.txb.pure.option('u64', index ?? undefined);
-        const to_obj = this.txb.pure.option('address', to_object ?? undefined);
+
+        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
 
         if (passport) {
-            return this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('withdraw_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(amount), 
-                    this.txb.pure.string(tips), for_obj, idx, to_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.token_type],
-            })
+            if (param.for_guard) {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_forGuard_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', param.items.map(v=>v.address)), 
+                        this.txb.pure.vector('u64', param.items.map(v=>v.amount)), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(param.for_guard), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })
+            } else {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', param.items.map(v=>v.address)), 
+                        this.txb.pure.vector('u64', param.items.map(v=>v.amount)), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })
+            }
         } else {
-            return this.txb.moveCall({
-                target:Protocol.Instance().TreasuryFn('withdraw') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(amount), 
-                    this.txb.pure.string(tips), for_obj, idx, to_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.token_type],
-            })
+            if (param.for_guard) {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_forGuard') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', param.items.map(v=>v.address)), 
+                        this.txb.pure.vector('u64', param.items.map(v=>v.amount)), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(param.for_guard), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })
+            } else {
+                console.log(param)
+                return this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', param.items.map(v=>v.address)), 
+                        this.txb.pure.vector('u64', param.items.map(v=>v.amount)), this.txb.pure.u64(param.index),
+                        this.txb.pure.string(param.remark), for_obj, this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })
+            }
         }
     }
 
@@ -225,15 +296,11 @@ export class Treasury {
         this.permission = new_permission
     }
     static parseObjectType = (chain_type:string) : string =>  {
-        if (chain_type) {
-            const s = 'treasury::Treasury<'
-            const i = chain_type.indexOf(s);
-            if (i > 0) {
-                let r = chain_type.slice(i + s.length, chain_type.length-1);
-                return r
-            }
-        }
-        return '';
+        return parseObjectType(chain_type, 'treasury::Treasury<')
     }
+
+    static OP_WITHDRAW = 0;
+    static OP_DEPOSIT = 1;
+    static OP_RECEIVE = 2;
 }
 

package/src/utils.ts

@@ -119,6 +119,17 @@ export const concatenate = (resultConstructor:any, ...arrays:any[]) => {
     return result;
 }
 
+export const parseObjectType = (chain_type:string | null | undefined, header:string='payment::Payment<') : string =>  {
+    if (chain_type) {
+        const i = chain_type.indexOf(header);
+        if (i > 0) {
+            let r = chain_type.slice(i + header.length, chain_type.length-1);
+            return r
+        }
+    }
+    return '';
+}
+
 export const array_equal =  (arr1: any[], arr2: any[]) => {
     if (arr1.length !== arr2.length) {
       return false;
@@ -399,20 +410,17 @@ export const IsValidBigint = (value:string | number | undefined | bigint, max:bi
     }; return false
 }
 
-export const IsValidUintLarge = (value:string | number | undefined | bigint) : boolean => {
-    return IsValidBigint(value, MAX_U64, BigInt(0))
-}
-export const IsValidU8 = (value:string | number | undefined | bigint) : boolean => {
-    return IsValidBigint(value, MAX_U8, BigInt(0))
+export const IsValidU8 = (value:string | number | undefined | bigint, min=0) : boolean => {
+    return IsValidBigint(value, MAX_U8, BigInt(min))
 }
-export const IsValidU64 = (value:string | number | undefined | bigint) : boolean => {
-    return IsValidBigint(value, MAX_U64, BigInt(0))
+export const IsValidU64 = (value:string | number | undefined | bigint, min=0) : boolean => {
+    return IsValidBigint(value, MAX_U64, BigInt(min))
 }
-export const IsValidU128 = (value:string | number | undefined | bigint) : boolean => {
-    return IsValidBigint(value, MAX_U128, BigInt(0))
+export const IsValidU128 = (value:string | number | undefined | bigint, min=0) : boolean => {
+    return IsValidBigint(value, MAX_U128, BigInt(min))
 }
-export const IsValidU256 = (value:string | number | undefined | bigint) : boolean => {
-    return IsValidBigint(value, MAX_U256, BigInt(0))
+export const IsValidU256 = (value:string | number | undefined | bigint, min=0) : boolean => {
+    return IsValidBigint(value, MAX_U256, BigInt(min))
 }
 
 export const IsValidTokenType = (argType: string) : boolean => { 
@@ -466,19 +474,40 @@ export const ResolveU64 = (value:bigint) : bigint => {
     }
 }
 
+function removeTrailingZeros(numberString: string): string {
+    const trimmedString = numberString.trim();
+    const decimalIndex = trimmedString.indexOf('.');
+    
+    if (decimalIndex !== -1) {
+      let endIndex = trimmedString.length - 1;
+      
+      while (trimmedString[endIndex] === '0') {
+        endIndex--;
+      }
+      
+      if (trimmedString[endIndex] === '.') {
+        endIndex--; // 如果小数点后面全是零，也去掉小数点
+      }
+      
+      return trimmedString.slice(0, endIndex + 1);
+    }
+    
+    return trimmedString;
+  }
+
 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;
+       return removeTrailingZeros('.' + (balance));
     } else if (pos < 0) {
         let start = balance.slice(0, Math.abs(pos));
         let end = balance.slice(Math.abs(pos));
-        return start + '.' + end;
+        return removeTrailingZeros(start + '.' + end);
     } else {
-        return '.' + balance.padStart(decimals, '0');
+        return removeTrailingZeros('.' + balance.padStart(decimals, '0'));
     }
 }