wowok 1.4.25 → 1.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.4.25",
+  "version": "1.4.28",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -36,7 +36,10 @@
     "grantor",
     "grantee",
     "move language",
-    "move"
+    "move",
+    "treasury",
+    "payment",
+    "Withholding"
   ],
   "author": "wowok",
   "license": "Apache-2.0",

package/src/demand.ts

@@ -1,6 +1,6 @@
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject, ResourceObject} from './protocol';
-import { IsValidDesription, IsValidAddress, IsValidArgType, IsValidU64, } from './utils'
+import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject } from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidArgType, IsValidU64, parseObjectType } from './utils'
 import { Errors, ERROR}  from './exception'
 
 export class Demand {
@@ -250,16 +250,8 @@ export class Demand {
         })    
         this.permission = new_permission
     }
-    static parseObjectType = (chain_type:string) : string =>  {
-        if (chain_type) {
-            const s = 'demand::Demand<'
-            const i = chain_type.indexOf(s);
-            if (i > 0) {
-                let r = chain_type.slice(i + s.length, chain_type.length-1);
-                return r
-            }
-        }
-        return '';
+    static parseObjectType = (chain_type?:string | null) : string =>  {
+        return parseObjectType(chain_type, 'demand::Demand<')
     }
 
     static MAX_BOUNTY_COUNT = 300;

package/src/guard.ts

@@ -263,19 +263,19 @@ export class Guard {
         [MODULES.vote, 'Voted Time by Address', 1113, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The time of whether an address has been voted on.', ['adddress']], 
  
         [MODULES.payment, 'Sender', 1200, [], ValueType.TYPE_ADDRESS, 'Payment originator address.', []], 
-        [MODULES.payment, 'Total Amount', 1201, [], ValueType.TYPE_U64, "Payment amount.", []], 
-        [MODULES.payment, 'Tips', 1202, [], ValueType.TYPE_STRING, 'Payment remarks.', ['address']], 
+        [MODULES.payment, 'Total Amount', 1201, [], ValueType.TYPE_U128, "Payment amount.", []], 
+        [MODULES.payment, 'Remark', 1202, [], ValueType.TYPE_STRING, 'Payment remark.', ['address']], 
         [MODULES.payment, 'Has Guard for Perpose', 1203, [], ValueType.TYPE_BOOL, 'Whether the payment references a Guard?', []], 
         [MODULES.payment, 'Has Object for Perpose', 1204, [], ValueType.TYPE_BOOL, 'Whether the payment references an Object?', []], 
         [MODULES.payment, 'Guard for Perpose', 1205, [], ValueType.TYPE_ADDRESS, 'The Guard referenced by this payment.', []], 
         [MODULES.payment, 'Object for Perpose', 1206, [], ValueType.TYPE_ADDRESS, "The Object referenced by this payment.", []], 
-        [MODULES.payment, 'Number of Transfer', 1207, [], ValueType.TYPE_U64, 'Number of recipients to receive payment from.', []], 
+        [MODULES.payment, 'Number of Recipients', 1207, [], ValueType.TYPE_U64, 'Number of recipients to receive payment from.', []], 
         [MODULES.payment, 'Is a Recipient', 1208, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a recipient received the payment?', ['address']], 
         [MODULES.payment, 'Amount for a Recipient', 1209, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The amount of payment received by an address.', ['address']], 
         [MODULES.payment, 'Time', 1210, [], ValueType.TYPE_U64, 'Payment time', []], 
         [MODULES.payment, 'Is from Treasury', 1211, [], ValueType.TYPE_BOOL, 'Whether the payment comes from a Treasury?', []], 
         [MODULES.payment, 'Treasury Address', 1212, [], ValueType.TYPE_ADDRESS, 'The Treasury from which the payment comes.', []], 
-        [MODULES.payment, 'Index', 1213, [], ValueType.TYPE_U64, 'Payment index or id.', []], 
+        [MODULES.payment, 'Biz-ID', 1213, [], ValueType.TYPE_U64, 'Bisiness ID number of the payment.', []], 
 
         [MODULES.withholding, 'Amount', 1300, [], ValueType.TYPE_U64, 'Total amount deposited with withholding.' , []], 
         [MODULES.withholding, 'Original Type Deposited', 1301, [], ValueType.TYPE_STRING, "Original type name of asserts deposited.", []], 
@@ -296,11 +296,10 @@ export class Guard {
         [MODULES.treasury, 'Permission', 1400, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []], 
         [MODULES.treasury, 'Balance', 1401, [], ValueType.TYPE_U64, "Treasury balance.", []], 
         [MODULES.treasury, 'Number of Flow Records', 1402, [], ValueType.TYPE_U64, 'Number of treasury transactions.', []], 
-        [MODULES.treasury, 'Deposit Flow', 1403, [], ValueType.TYPE_U128, 'Treasury inflow amount.', []], 
-        [MODULES.treasury, 'Withdraw Flow', 1404, [], ValueType.TYPE_U128, 'Treasury outflow amount.', []], 
-        [MODULES.treasury, 'Flow over a Period of Time', 1405, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, 'The flow amount between certain periods.', ['begin time', 'end time']], 
-        [MODULES.treasury, 'Deposit Flow over a Period of Time', 1406, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, "The inflow amount between certain periods.", ['begin time', 'end time']], 
-        [MODULES.treasury, 'Withdraw Flow over a Period of Time', 1407, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, 'The outflow amount between certain periods.', ['begin time', 'end time']], 
+        [MODULES.treasury, 'Inflow Amount', 1403, [], ValueType.TYPE_U128, 'Treasury inflow amount.', []], 
+        [MODULES.treasury, 'Outflow Amount', 1404, [], ValueType.TYPE_U128, 'Treasury outflow amount.', []], 
+        [MODULES.treasury, 'Number of Payment', 1405, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of flows generated by a payment.', ['payment address']], 
+        [MODULES.treasury, 'Can anyone deposit ', 1406, [], ValueType.TYPE_BOOL, "Whether to allow any address to deposit?", []], 
     ];
 
     static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);

package/src/index.ts

@@ -14,4 +14,6 @@ export * from './graphql'
 export * from './entity'
 export * from './wowok'
 export * from './resource'
-export * from './treasury'
+export * from './treasury'
+export * from './payment'
+export * from './withholding'

package/src/passport.ts

@@ -94,7 +94,7 @@ export class GuardParser {
 
         // console.log(res[0].data?.content);
         let content = res[0].data!.content as any;
-        if (content?.type != protocol.Package() + '::guard::Guard') {
+        if (content?.type != protocol.Package('base') + '::guard::Guard') {
             ERROR(Errors.Fail, 'GuardObject object invalid')
         }
 
@@ -255,12 +255,11 @@ export class GuardParser {
         res.forEach((r) => {
             const c = r.data?.content as any;
             if (!c) ERROR(Errors.Fail, 'Parse_Guard_Helper invalid content');
-
             const index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => {return v.includes('guard::Guard') && v == c.type});
             if (index === -1) ERROR(Errors.Fail, 'Parse_Guard_Helper invalid type: ' + c.type);
 
 
-            if (c.fields.input.type === (protocol.Package() + '::bcs::BCS')) {
+            if (c.fields.input.type === (protocol.Package('base') + '::bcs::BCS')) {
                 const constants = GuardParser.parse_constant(c.fields.constants); // MUST first
                 const inputs = GuardParser.parse_bcs(constants, Uint8Array.from(c.fields.input.fields.bytes));
                 me.guard_list.push({id: c.fields.id.id, input:[...inputs],  constant:[...constants], digest:r.data?.digest??'', version:r.data?.version ?? ''});

package/src/payment.ts

@@ -0,0 +1,63 @@
+import { CoinObject, FnCallType, PaymentAddress, Protocol, TxbObject} from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidArray, } from './utils';
+import { ERROR, Errors } from './exception';
+import { Transaction as TransactionBlock} from '@mysten/sui/transactions';
+
+export interface Payment_Receiver {
+    address: string;
+    coin: CoinObject;
+}
+
+export interface PaymentParam {
+    receiver: Payment_Receiver[];
+    business_index: bigint;
+    business_remark: string;
+    for_object?: string;
+    for_guard?: string;
+}
+
+export const  PAYMENT_MAX_RECEIVER_COUNT = 200;
+export function create_payment(txb:TransactionBlock, pay_token_type:string, param:PaymentParam) : PaymentAddress {
+    if (!pay_token_type) ERROR(Errors.InvalidParam, 'Payment.New.pay_token_type');
+
+    if (param.receiver.length > PAYMENT_MAX_RECEIVER_COUNT)  {
+        ERROR(Errors.InvalidParam, 'Payment.New.param.receiver');
+    }
+
+    if (!IsValidArray(param.receiver, (item:Payment_Receiver) => { return IsValidAddress(item.address) && Protocol.IsValidObjects([item.coin])})) {
+        ERROR(Errors.IsValidArray, 'Payment.New.param.receiver');
+    }
+
+    if (param?.for_object && !IsValidAddress(param.for_object)) {
+        ERROR(Errors.IsValidAddress, 'Payment.New.param.for_object')
+    }
+    if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+        ERROR(Errors.IsValidAddress, 'Payment.New.param.for_guard')
+    }
+    if (param?.business_remark && !IsValidDesription(param?.business_remark)) {
+        ERROR(Errors.IsValidDesription, 'Payment.New.param.business_remark')
+    }
+    
+    let obj = txb.pure.option('address', param.for_object ?  param.for_object : undefined);
+    const clock = txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+    if (param.for_guard) {
+        return txb.moveCall({
+            target:Protocol.Instance().PaymentFn('create_withGuard') as FnCallType,
+            arguments:[txb.pure.vector('address', param.receiver.map((i)=>i.address)), txb.makeMoveVec({elements:param.receiver.map((i)=>i.coin)}), 
+                obj, txb.object(param.for_guard), txb.pure.u64(param.business_index), txb.pure.string(param.business_remark), txb.object(clock)],
+            typeArguments:[pay_token_type],
+        })                
+    } else {
+        return txb.moveCall({
+            target:Protocol.Instance().PaymentFn('new') as FnCallType,
+            arguments:[txb.pure.vector('address', param.receiver.map((i)=>i.address)), txb.makeMoveVec({elements:param.receiver.map((i)=>i.coin)}), 
+                obj, txb.pure.u64(param.business_index), txb.pure.string(param.business_remark), txb.object(clock)],
+            typeArguments:[pay_token_type],
+        })                
+    }
+}
+
+
+
+    

package/src/permission.ts

@@ -79,10 +79,12 @@ export enum PermissionIndex {
     progress_parent = 655,
 
     treasury = 700,
-    treasury_deposit = 701,
-    treasury_withdraw = 702,
-    treasury_free_deposit_set = 703,
+    treasury_receive = 701,
+    treasury_deposit = 702,
+    treasury_withdraw = 703,
     treasury_descritption = 704, 
+    treasury_free_deposit_set = 705,
+
     user_defined_start = 1000,
 }
 
@@ -183,6 +185,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     
     {index:PermissionIndex.treasury, name: 'Treasury', description:'Launch new Treasury', module: 'treasury'},
     {index:PermissionIndex.treasury_deposit, name: 'Deposit', description:'Deposit coins', module: 'treasury'},
+    {index:PermissionIndex.treasury_receive, name: 'Receive', description:'Receive coins from some address sent', module: 'treasury'},
     {index:PermissionIndex.treasury_withdraw, name: 'Withdraw', description:'Withdraw coins', module: 'treasury'},
     {index:PermissionIndex.treasury_free_deposit_set, name: 'Be Free Deposit', description:'Set whether deposits can be made without permission', module: 'treasury'},
     {index:PermissionIndex.treasury_descritption, name: 'Description', description:'Set Treasury description', module: 'treasury'},

package/src/progress.ts

@@ -78,7 +78,6 @@ export class Progress {
     }
 
     launch() : ProgressAddress {
-        
         return this.txb.moveCall({
             target:Protocol.Instance().ProgressFn('create') as FnCallType,
             arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],

package/src/protocol.ts

@@ -9,9 +9,7 @@ import { isValidSuiAddress, isValidSuiObjectId } from '@mysten/sui/utils'
 
 export enum MODULES {
     machine = 'machine',
-    node = 'node',
     progress = 'progress',
-    community = 'community',
     repository = 'repository',
     permission = 'permission',
     passport = 'passport',
@@ -56,6 +54,11 @@ export type ResourceObject = TransactionResult | string | TransactionArgument;
 export type ResourceAddress = TransactionResult;
 export type EntityObject = TransactionResult | string | TransactionArgument;
 export type EntityAddress = TransactionResult;
+export type TreasuryAddress = TransactionResult;
+export type PaymentObject = TransactionResult | string | TransactionArgument;
+export type PaymentAddress = TransactionResult;
+export type ReceivedObject = TransactionResult | string | TransactionArgument;
+export type CoinWrapperObject = TransactionResult;
 
 export type TxbObject = string | TransactionResult | TransactionArgument | GuardObject |  RepositoryObject | PermissionObject | MachineObject | PassportObject |
     DemandObject | ServiceObject | RewardObject | OrderObject | DiscountObject | VoteObject | DemandObject | ResourceObject | EntityObject;
@@ -204,20 +207,23 @@ export enum ENTRYPOINT {
 }
 /*
 const TESTNET = {
-    package: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
+    wowok: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
     wowok_object: '0xb0a521a287e9d5e08932b3984dbe6ce159e836179c41bd08c556ef77ecdb7439',
     entity_object: '0x16aab98920e7341d1dc19631031253234b2b71fc2ab8c32d65ee3ded8072acef',
     treasury_cap:'0xb75a2ca2f651755c134ad521175f33f9e3f9008ad44340f76b3229e1f30cfdff',
 }
 */
 const TESTNET = {
-    package: "0x0a0a86d4d364ba566d5392cd8ba7d980f4d65fc1e1586e5b2e49b0ecd8dfeae4",
-    wowok_object: '0x8e5424a7899597dc75b456d597dd0a741296c1363282a72d52421b1c85d2460e',
-    entity_object: '0xd88aaf554750437ab4148acca27e0ba51cff97c13882722a4a89289e57a7b8fa',
-    treasury_cap:'0x01079f2baa2c320afc52e0f2680167c44bbaad9a6a21514bfd2e56356028be9d',
+    wowok: "0x6c0d4f3c5f1ceb981721cd44c516bbeadf22f53791906ed00893a64bb788d56c",
+    wowok_origin:'0xa487291ecede9b713400360ce81d242ad227af8184f07ace1a3dab1bfc920660' ,
+    base: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
+    wowok_object: '0xb56d70321b3205e994eb8e7664eabc91f361a55d75f363a321c8d4cf012fd6b2',
+    entity_object: '0x33881b1d2a65886c3068917a20d849e3956771df1bceb7a05678e40bcff30aa2',
+    treasury_cap:'0x538cf8f32d59f58c0450a3a97c1eeed3096f4ce63e07e0bdf343a5cc1464887c',
 }
 const MAINNET = {
-    package: "",
+    wowok: "",
+    base:"",
     wowok_object: '',
     entity_object: '',
     treasury_cap:'',
@@ -231,7 +237,7 @@ export interface CoinTypeInfo {
 }
 export class Protocol {
     protected network = '';
-    protected package = '';
+    protected package = new Map<string, string>();
     protected signer = '';
     protected wowok_object = '';
     protected entity_object = '';
@@ -262,14 +268,17 @@ export class Protocol {
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = TESTNET.package;
+                this.package.set('wowok', TESTNET.wowok);
+                this.package.set('base', TESTNET.base);
+                this.package.set('wowok_origin', TESTNET.wowok_origin); //@ orgin package!!!
                 this.wowok_object = TESTNET.wowok_object;
                 this.entity_object= TESTNET.entity_object;
                 this.treasury_cap = TESTNET.treasury_cap;
                 this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
             case ENTRYPOINT.mainnet:
-                this.package = MAINNET.package;
+                this.package.set('wowok', MAINNET.wowok);
+                this.package.set('base', MAINNET.base);
                 this.wowok_object = MAINNET.wowok_object;
                 this.entity_object= MAINNET.entity_object;
                 this.treasury_cap = MAINNET.treasury_cap;
@@ -277,7 +286,10 @@ export class Protocol {
                 break;
         };
     }
-    Package(): string { return this.package }
+    Package(type:string): string { 
+        return this.package.get(type) ?? ''
+    }
+
     WowokObject(): string { return this.wowok_object }
     EntityObject(): string { return this.entity_object }
     TreasuryCap() : string { return this.treasury_cap }
@@ -296,22 +308,24 @@ export class Protocol {
         }; return "";
     };
     
-    MachineFn = (fn:any) => { return `${this.package}::${MODULES.machine}::${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}`};
-    PermissionFn = (fn: any) => { return `${this.package}::${MODULES.permission}::${fn}`};
-    PassportFn = (fn:any) => { return `${this.package}::${MODULES.passport}::${fn}`};
-    GuardFn = (fn: any) => { return `${this.package}::${MODULES.guard}::${fn}`};
-    VoteFn = (fn:any) => { return `${this.package}::${MODULES.vote}::${fn}`};
-    DemandFn = (fn: any) => { return `${this.package}::${MODULES.demand}::${fn}`};
-    OrderFn = (fn:any) => { return `${this.package}::${MODULES.order}::${fn}`};
-    RewardFn = (fn: any) => { return `${this.package}::${MODULES.reward}::${fn}`};
-    ServiceFn = (fn: any) => { return `${this.package}::${MODULES.service}::${fn}`};
-    ResourceFn = (fn: any) => { return `${this.package}::${MODULES.resource}::${fn}`};
-    EntityFn = (fn: any) => { return `${this.package}::${MODULES.entity}::${fn}`};
-    WowokFn = (fn: any) => { return `${this.package}::${MODULES.wowok}::${fn}`};
-    TreasuryFn = (fn: any) => { return `${this.package}::${MODULES.treasury}::${fn}`};
+    MachineFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.machine}::${fn}`};
+    ProgressFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.progress}::${fn}`};
+    RepositoryFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.repository}::${fn}`};
+    PermissionFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.permission}::${fn}`};
+    PassportFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.passport}::${fn}`};
+    VoteFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.vote}::${fn}`};
+    DemandFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.demand}::${fn}`};
+    OrderFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.order}::${fn}`};
+    RewardFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.reward}::${fn}`};
+    ServiceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.service}::${fn}`};
+    ResourceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.resource}::${fn}`};
+    EntityFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.entity}::${fn}`};
+    WowokFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.wowok}::${fn}`};
+    TreasuryFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.treasury}::${fn}`};
+    PaymentFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.payment}::${fn}`};
+    WithholdingFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.withholding}::${fn}`};
+    GuardFn = (fn: any) => { return `${this.package.get('base')}::${MODULES.guard}::${fn}`};
+    MintFn = (fn: any) => { return `${this.package.get('base')}::${MODULES.wowok}::${fn}`};
     
     Query = async (objects: Query_Param[], options:SuiObjectDataOptions={showContent:true}) : Promise<SuiObjectResponse[]> => {
         const client =  new SuiClient({ url: this.NetworkUrl() });  
@@ -342,7 +356,6 @@ export class Protocol {
 
         const privkey = fromHEX(priv_key);
         const keypair = Ed25519Keypair.fromSecretKey(privkey);
-
         const response = await client.signAndExecuteTransaction({
             transaction: this.CurrentSession(), 
             signer: keypair,
@@ -356,8 +369,8 @@ export class Protocol {
     static SUI_TOKEN_TYPE = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'; // TOKEN_TYPE
     // used in demand, reward, ...
     static SUI_COIN_TYPE = '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<0x2::sui::SUI>'; // COIN TYPE
-    WOWOK_TOKEN_TYPE = () => { return this.package + '::wowok::WOWOK' }
-    WOWOK_COIN_TYPE = () => {  return '0x2::coin::Coin<' + this.package + '::wowok::WOWOK>'}
+    WOWOK_TOKEN_TYPE = () => { return this.package.get('base') + '::wowok::WOWOK' }
+    WOWOK_COIN_TYPE = () => {  return '0x2::coin::Coin<' + this.package.get('base') + '::wowok::WOWOK>'}
     COINS_TYPE = () => { 
         switch(this.network) {
             case ENTRYPOINT.testnet:
@@ -392,13 +405,13 @@ export class Protocol {
     CoinTypes_Testnet:CoinTypeInfo[] = [
         {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
         {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
-        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+        {symbol:'WOW', type:TESTNET.base + '::wowok::WOWOK', decimals:9},
     ];
 
     CoinTypes_Mainnet:CoinTypeInfo[] = [
         {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
         {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
-        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+        {symbol:'WOW', type:TESTNET.base + '::wowok::WOWOK', decimals:9},
         {symbol:'USDT', type:'0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN', decimals:6},
         {symbol:'USDC', type:'0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN', decimals:6},              
         {symbol:'WETH', type:'0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN', decimals:8},
@@ -438,13 +451,20 @@ export class Protocol {
         })
     }  
     WOWOK_OBJECTS_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
-        { let i = this.package + '::' + key + '::';  return i + capitalize(key); })
+        { let i = (key === MODULES.guard ? this.package.get('base') : this.package.get('wowok')) + '::' + key + '::';  return i + capitalize(key); })
     WOWOK_OBJECTS_PREFIX_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
-        { return this.package + '::' + key + '::'; })
+        { return (key === MODULES.guard ? this.package.get('base') : this.package.get('wowok'))  + '::' + key + '::'; })
+    private hasPackage(pack:string) : boolean {
+        for (let value of this.package.values()) {
+            if (value === pack) {
+                return true;
+            }
+        } return false;
+    }
     object_name_from_type_repr = (type_repr:string) : string => {
         if (!type_repr) return ''
         let i = type_repr.indexOf('::');
-        if (i > 0 && type_repr.slice(0, i) === this.package) {
+        if (i > 0 && this.hasPackage(type_repr.slice(0, i))) {
             i = type_repr.indexOf('<');
             if (i > 0) {
                 type_repr = type_repr.slice(0, i);
@@ -457,6 +477,22 @@ export class Protocol {
         }
         return ''
     }
+    module_object_name_from_type_repr = (type_repr:string) : string => {
+        if (!type_repr) return ''
+        let i = type_repr.indexOf('::');
+        if (i > 0 && this.hasPackage(type_repr.slice(0, i))) {
+            i = type_repr.indexOf('<');
+            if (i > 0) {
+                type_repr = type_repr.slice(0, i);
+            }
+            
+            let n = type_repr.indexOf('::');
+            if (n > 0) {
+                return type_repr.slice(n+2);
+            }
+        }
+        return ''
+    }
 }
 
 export class RpcResultParser {
@@ -471,8 +507,7 @@ export class RpcResultParser {
         if (response?.objectChanges) {
             response.objectChanges.forEach((change) => {
                 RpcResultParser.Object_Type_Extra().forEach((name) => {
-                    let type = protocol.Package() + '::' + name;
-                    if (change.type == 'created' && change.objectType.includes(type)) {
+                    if (change.type == 'created' && protocol.module_object_name_from_type_repr(change.objectType)===name)  {
                         if (ret.has(name)) {
                             ret.get(name)?.push(change.objectId);
                         } else {

package/src/repository.ts

@@ -2,7 +2,7 @@ import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress
 import { PermissionIndexType, Permission } from './permission'
 import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, IsValidName,  ValueTypeConvert} from './utils';
 import { ERROR, Errors } from './exception';
-import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, stringToUint8Array } from './utils';
+import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, parseObjectType } from './utils';
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
 export enum Repository_Policy_Mode {
@@ -394,16 +394,8 @@ export class Repository {
     static IsValidValue = (value:Uint8Array)  => {
         return value.length < Repository.MAX_VALUE_LENGTH;
     }
-    static parseObjectType = (chain_type:string) : string =>  {
-        if (chain_type) {
-            const s = 'repository::Repository<'
-            const i = chain_type.indexOf(s);
-            if (i > 0) {
-                let r = chain_type.slice(i + s.length, chain_type.length-1);
-                return r
-            }
-        }
-        return '';
+    static parseObjectType = (chain_type?:string | null) : string =>  {
+        return parseObjectType(chain_type, 'repository::Repository<');
     }
 
     static rpc_de_data(fields:any) : RepData [] {

package/src/resource.ts

@@ -21,6 +21,8 @@ export class Resource {
     static LikeName = "like";
     static DislikeName = "dislike";
     static FavorName = "favor";
+    static LaunchName = 'launch';
+    static OrderName = 'order';
 
     protected object:TxbObject;
     protected txb;
@@ -55,14 +57,14 @@ export class Resource {
         });
     }
 
-    add2(object:string, name:string[])  {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
+    add2(object:TxbObject, name:string[])  {
+        if (typeof(object) === 'string' && !IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
         if (!IsValidArray(name, IsValidName)) ERROR(Errors.IsValidArray, 'add2');
         if (!name) return 
 
         this.txb.moveCall({
             target:Protocol.Instance().ResourceFn('add2')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object), 
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
                 this.txb.pure.vector('string', name)]
         });
     }

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, IsValidU64} from './utils';
+import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription, IsValidU64, parseObjectType} from './utils';
 import { ERROR, Errors } from './exception';
 
 export type CoinReward = TransactionResult;
@@ -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 ;
@@ -27,10 +47,10 @@ export class Treasury {
     static New(txb:TransactionBlock, token_type:string, permission:PermissionObject, description:string, 
         bFreeDeposit:boolean=false, passport?:PassportObject) : Treasury {
         if (!Protocol.IsValidObjects([permission])) {
-            ERROR(Errors.IsValidObjects, 'permission, bounty');
+            ERROR(Errors.IsValidObjects, 'Treasury.New permission, bounty');
         }
         if (!IsValidDesription(description)) {
-            ERROR(Errors.IsValidDesription);
+            ERROR(Errors.IsValidDesription, 'Treasury.New.description');
         } 
         if (!IsValidArgType(token_type)) {
             ERROR(Errors.IsValidArgType, token_type);
@@ -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?:bigint, 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:bigint, tips:string, for_object?:string, index?:bigint, 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;
@@ -463,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'));
     }
 }
 

package/src/withholding.ts

@@ -0,0 +1,167 @@
+import { FnCallType, PaymentObject, ReceivedObject, PaymentAddress, Protocol, TxbObject, CoinObject, PassportObject} from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidArray, IsValidU64, parseObjectType } from './utils';
+import { ERROR, Errors } from './exception';
+import { DepositParam, WithdrawParam, WithdrawItem } from './treasury';
+import { Transaction as TransactionBlock} from '@mysten/sui/transactions';
+
+export interface WithholdingGuard {
+    guard: string,
+    amount: bigint,
+}
+export interface WithholdingParam {
+    guards: WithholdingGuard[],
+    description: string,
+}
+
+export class Withholding {
+    protected object : TxbObject;
+    protected pay_token_type;
+    protected txb;
+    
+    get_pay_type() {  return this.pay_token_type }
+    get_object() { return this.object }
+    private constructor(txb:TransactionBlock, pay_token_type:string, ) {
+        this.object = '';
+        this.pay_token_type = pay_token_type;
+        this.txb = txb;
+    }
+
+    static From(txb:TransactionBlock, pay_token_type:string, object:TxbObject) : Withholding {
+        if (!pay_token_type) ERROR(Errors.InvalidParam, 'Withholding.From.pay_token_type');
+        let v = new Withholding(txb, pay_token_type);
+        v.object = Protocol.TXB_OBJECT(txb, object)
+        return v
+    }
+
+    static New(txb:TransactionBlock, pay_token_type:string, param:WithholdingParam) : Withholding {
+        if (!pay_token_type) ERROR(Errors.InvalidParam, 'Withholding.New_fromAddress.pay_token_type');
+        if (!IsValidDesription(param.description)) ERROR(Errors.IsValidDesription, 'Withholding.New.param')
+
+        if (param.guards.length === 0 || param.guards.length > Withholding.MAX_GUARD_COUNT) {
+            ERROR(Errors.InvalidParam, 'Withholding.New.param.guards length')
+        }
+        if (!IsValidArray(param.guards, (item:WithholdingGuard) => IsValidAddress(item.guard) && IsValidU64(item.amount))) {
+            ERROR(Errors.InvalidParam, 'Withholding.New.param.guards')
+        }
+
+        let v = new Withholding(txb, pay_token_type);    
+        v.object = txb.moveCall({
+            target:Protocol.Instance().WithholdingFn('new') as FnCallType,
+            arguments:[txb.pure.string(param.description)],
+            typeArguments:[pay_token_type],
+        })    
+
+        param.guards.forEach((i) => {   
+            v.object = txb.moveCall({
+                target:Protocol.Instance().WithholdingFn('add_guard') as FnCallType,
+                arguments:[txb.object(v.object), txb.object(i.guard), txb.pure.u64(i.amount)],
+                typeArguments:[pay_token_type],
+            })      
+        })
+        return v
+    }
+
+    launch() : PaymentAddress {
+        return this.txb.moveCall({
+            target:Protocol.Instance().WithholdingFn('create') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)],
+            typeArguments:[this.pay_token_type],
+        })
+    }
+
+    receive(payment:PaymentObject, received:ReceivedObject) {
+        if (!Protocol.IsValidObjects([payment, received])) {
+            ERROR(Errors.IsValidArray, 'receive.payment&received');
+        }
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        return this.txb.moveCall({
+            target:Protocol.Instance().WithholdingFn('receive') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(received), this.txb.object(payment), 
+                this.txb.object(clock)],
+            typeArguments:[this.pay_token_type],
+        })
+    }
+
+    deposit(param:DepositParam) {
+        if (!Protocol.IsValidObjects([param.coin])) {
+            ERROR(Errors.IsValidObjects, 'deposit.param.coin')
+        }
+        if (!IsValidDesription(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'deposit.param.remark')
+        }
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'deposit.param.for_object')
+        }
+        if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+            ERROR(Errors.IsValidAddress, 'deposit.param.for_guard')
+        }
+        if (param.index !== undefined && !IsValidU64(param.index)) {
+            ERROR(Errors.InvalidParam, 'deposit.param.index')
+        }
+
+        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        if (param.for_guard) {
+            return this.txb.moveCall({
+                target:Protocol.Instance().WithholdingFn('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.pay_token_type],
+            })
+        } else {
+            return this.txb.moveCall({
+                target:Protocol.Instance().WithholdingFn('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.pay_token_type],
+            })
+        }
+    }
+
+    // param.treasury -> coins ; param.receiver -> null
+    withdraw(guard:string, 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(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'withdraw.param.remark')
+        }
+        if (!IsValidU64(param.index)) {
+            ERROR(Errors.IsValidU64, 'withdraw.param.index')
+        }
+        if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.for_guard')
+        }
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.for_object')
+        }
+
+        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        if (param.for_guard) {
+            return this.txb.moveCall({
+                target:Protocol.Instance().WithholdingFn('withdraw_forGuard') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(guard), this.txb.object(passport), 
+                    this.txb.pure.vector('address', param.items.map(i=>i.address)), this.txb.pure.vector('u64', param.items.map(i=>i.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)],
+                typeArguments:[this.pay_token_type],
+            })
+        } else {
+            return this.txb.moveCall({
+                target:Protocol.Instance().WithholdingFn('withdraw') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(guard), this.txb.object(passport), 
+                    this.txb.pure.vector('address', param.items.map(i=>i.address)), this.txb.pure.vector('u64', param.items.map(i=>i.amount)),
+                    this.txb.pure.u64(param.index), this.txb.pure.string(param.remark), for_obj, this.txb.object(clock)],
+                typeArguments:[this.pay_token_type],
+            })
+        }
+    }
+    static parseObjectType = (chain_type:string) : string =>  {
+        return parseObjectType(chain_type, 'withholding::Withholding<')
+    }
+    static  MAX_GUARD_COUNT = 16;
+}

package/src/wowok.ts

@@ -52,7 +52,7 @@ export class Wowok {
         if (!IsValidAddress(recipient)) ERROR(Errors.IsValidAddress, 'mint');
         if (!IsValidU64(amount)) ERROR(Errors.IsValidU64, 'mint');
         this.txb.moveCall({
-            target:Protocol.Instance().WowokFn('mint') as FnCallType,
+            target:Protocol.Instance().MintFn('mint') as FnCallType, //@ base package
             arguments:[Protocol.TXB_OBJECT(this.txb, Protocol.Instance().TreasuryCap()), this.txb.pure.u64(amount), 
                 this.txb.pure.address(recipient)]
         })