wowok 1.4.28 → 1.4.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.4.28",
+  "version": "1.4.31",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/guard.ts

@@ -277,29 +277,35 @@ export class Guard {
         [MODULES.payment, 'Treasury Address', 1212, [], ValueType.TYPE_ADDRESS, 'The Treasury from which the payment comes.', []], 
         [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.", []], 
-        [MODULES.withholding, 'Original Package', 1302, [], ValueType.TYPE_ADDRESS, 'Original package address of asserts deposited.', []], 
-        [MODULES.withholding, 'Original Module', 1303, [], ValueType.TYPE_STRING, 'Original module name of asserts deposited.', []], 
-        [MODULES.withholding, 'Type Deposited', 1304, [], ValueType.TYPE_STRING, 'Type name of asserts deposited.', []], 
-        [MODULES.withholding, 'Package', 1305, [], ValueType.TYPE_ADDRESS, 'Package address of asserts deposited.', , []], 
-        [MODULES.withholding, 'Module', 1306, [], ValueType.TYPE_STRING, 'Module name of asserts deposited.', []], 
-        [MODULES.withholding, 'Balance', 1307, [], ValueType.TYPE_U64, 'The amount currently remaining in withholding.', []], 
-        [MODULES.withholding, 'Deposit Time', 1308, [], ValueType.TYPE_U64, 'Deposit time.', []], 
-        [MODULES.withholding, 'Be Withdrawable', 1309, [], ValueType.TYPE_BOOL, 'Whether to allow amount withdrawal?' , []], 
-        [MODULES.withholding, 'Be Deposited from', 1310, [], ValueType.TYPE_BOOL, 'Is the deposit from source set?', []], 
-        [MODULES.withholding, 'Deposited from Object', 1311, [], ValueType.TYPE_ADDRESS, 'The source object set when depositing.', []], 
-        [MODULES.withholding, 'Contains Guard', 1312, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether the guard for withdrawal is set up?', []], 
-        [MODULES.withholding, 'Withdrawal percentage', 1313, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U8, 'The percentage of withdrawals corresponding to Guard.', ['address']], 
-        [MODULES.withholding, 'Number of withdrawals', 1314, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Number of withdrawals.'], 
+        [MODULES.reward, 'Amount', 1300, [], ValueType.TYPE_U64, 'Total amount deposited with reward.' , []], 
+        [MODULES.reward, 'Original Type Deposited', 1301, [], ValueType.TYPE_STRING, "Original type name of asserts deposited.", []], 
+        [MODULES.reward, 'Original Package', 1302, [], ValueType.TYPE_ADDRESS, 'Original package address of asserts deposited.', []], 
+        [MODULES.reward, 'Original Module', 1303, [], ValueType.TYPE_STRING, 'Original module name of asserts deposited.', []], 
+        [MODULES.reward, 'Type Deposited', 1304, [], ValueType.TYPE_STRING, 'Type name of asserts deposited.', []], 
+        [MODULES.reward, 'Package', 1305, [], ValueType.TYPE_ADDRESS, 'Package address of asserts deposited.', , []], 
+        [MODULES.reward, 'Module', 1306, [], ValueType.TYPE_STRING, 'Module name of asserts deposited.', []], 
+        [MODULES.reward, 'Balance', 1307, [], ValueType.TYPE_U64, 'The amount currently remaining in reward.', []], 
+        [MODULES.reward, 'Deposit Time', 1308, [], ValueType.TYPE_U64, 'Deposit time.', []], 
+        [MODULES.reward, 'Be Withdrawable', 1309, [], ValueType.TYPE_BOOL, 'Whether to allow amount withdrawal?' , []], 
+        [MODULES.reward, 'Be Deposited from', 1310, [], ValueType.TYPE_BOOL, 'Is the deposit from source set?', []], 
+        [MODULES.reward, 'Deposited from Object', 1311, [], ValueType.TYPE_ADDRESS, 'The source object set when depositing.', []], 
+        [MODULES.reward, 'Contains Guard', 1312, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether the guard for withdrawal is set up?', []], 
+        [MODULES.reward, 'Withdrawal percentage', 1313, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U8, 'The percentage of withdrawals corresponding to Guard.', ['address']], 
+        [MODULES.reward, 'Number of withdrawals', 1314, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Number of withdrawals.'], 
 
         [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, '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?", []], 
+        [MODULES.treasury, 'Has Payment', 1405, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is there a payment in the Treasury flows?', ['payment address']], 
+        [MODULES.treasury, 'Has Deposit Guard', 1406, [], ValueType.TYPE_BOOL, 'Whether the deposit Guard set?', []], 
+        [MODULES.treasury, 'Deposit Guard', 1407, [], ValueType.TYPE_ADDRESS, 'Deposit Guard address.', []], 
+        [MODULES.treasury, 'Number of Withdraw Guards', 1408, [], ValueType.TYPE_U64, 'Number of withdraw guards.', []], 
+        [MODULES.treasury, 'Has Withdraw Guard', 1409, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Has a Withdraw Guard added?', ['guard address']], 
+        [MODULES.treasury, 'Withdrawal Amount with Guard', 1410, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'withdrawal amount corresponding the Guard.', ['guard address']], 
+        [MODULES.treasury, 'Has Payment with operation', 1411, [ValueType.TYPE_ADDRESS, ValueType.TYPE_U8], ValueType.TYPE_BOOL, 'Is there a payment with the operation in the Treasury flows?', ['payment address', 'operation']], 
+        [MODULES.treasury, 'Withdraw Mode', 1412, [], ValueType.TYPE_U8, 'Treasury withdrawal mode', []], 
     ];
 
     static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);

package/src/index.ts

@@ -1,6 +1,5 @@
 export * from './demand'
 export * from './progress'
-export * from './reward'
 export * from './utils'
 export * from './permission'
 export * from './guard'
@@ -16,4 +15,4 @@ export * from './wowok'
 export * from './resource'
 export * from './treasury'
 export * from './payment'
-export * from './withholding'
+export * from './reward'

package/src/permission.ts

@@ -83,7 +83,9 @@ export enum PermissionIndex {
     treasury_deposit = 702,
     treasury_withdraw = 703,
     treasury_descritption = 704, 
-    treasury_free_deposit_set = 705,
+    treasury_deposit_guard = 705,
+    treasury_withdraw_mode = 706,
+    treasury_withdraw_guard = 707,
 
     user_defined_start = 1000,
 }
@@ -151,12 +153,12 @@ export const PermissionInfo : PermissionInfoType[] = [
     //{index:PermissionIndex.service_change_order_required_pubkey, name:'Order pubkey', description:'Update Serivce order pubkey', module: 'service'},
     {index:PermissionIndex.service_pause, name:'Pause', description:'Pause/Unpause Service', module: 'service'},
 
-    {index:PermissionIndex.reward, name:'Reward', description:'Launch new Reward', module: 'reward'},
-    {index:PermissionIndex.reward_refund, name:'Refund', description:'Refund from Reward', module: 'reward'},
-    {index:PermissionIndex.reward_expand_time, name:'Expand deadline', description:'Expand Reward deadline', module: 'reward'},
-    {index:PermissionIndex.reward_guard, name:'Guard', description:'Set Reward guard', module: 'reward'},
-    {index:PermissionIndex.reward_description, name:'Description', description:'Set Reward description', module: 'reward'},
-    {index:PermissionIndex.reward_lock_guards, name:'Lock Guard', description:'Set Reward guard immutable', module: 'reward'},
+    {index:PermissionIndex.reward, name:'reward', description:'Launch new reward', module: 'reward'},
+    {index:PermissionIndex.reward_refund, name:'Refund', description:'Refund from reward', module: 'reward'},
+    {index:PermissionIndex.reward_expand_time, name:'Expand deadline', description:'Expand reward deadline', module: 'reward'},
+    {index:PermissionIndex.reward_guard, name:'Guard', description:'Set reward guard', module: 'reward'},
+    {index:PermissionIndex.reward_description, name:'Description', description:'Set reward description', module: 'reward'},
+    {index:PermissionIndex.reward_lock_guards, name:'Lock Guard', description:'Set reward guard immutable', module: 'reward'},
     {index:PermissionIndex.reward_claim_repeatably, name:'Claim repeatably', description:'Allow claimming repeatably', module: 'reward'},
     {index:PermissionIndex.reward_allow_claiming, name:'Allow claiming', description:'Allow claiming', module: 'reward'},
 
@@ -187,8 +189,9 @@ export const PermissionInfo : PermissionInfoType[] = [
     {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'},
+    {index:PermissionIndex.treasury_withdraw_guard, name: 'Withdraw Guard', description:'Add/Remove Treasury withdraw guard', module: 'treasury'},
+    {index:PermissionIndex.treasury_withdraw_mode, name: 'Withdraw mode', description:'Set Treasury withdraw mode', module: 'treasury'},
+    {index:PermissionIndex.treasury_deposit_guard, name: 'Deposit Guard', description:'Set Treasury deposit guard', module: 'treasury'},
 ]
 
 export type PermissionIndexType = PermissionIndex | number;

package/src/protocol.ts

@@ -24,7 +24,6 @@ export enum MODULES {
     wowok = 'wowok',
     treasury = 'treasury',
     payment = 'payment',
-    withholding = 'withholding',
 }
 
 export type PermissionAddress = TransactionResult;
@@ -214,11 +213,11 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x6c0d4f3c5f1ceb981721cd44c516bbeadf22f53791906ed00893a64bb788d56c",
-    wowok_origin:'0xa487291ecede9b713400360ce81d242ad227af8184f07ace1a3dab1bfc920660' ,
+    wowok: "0xdc41a2bf843f25c079205f763b5664d503300590329b01772e227bf62adef4dd",
+    wowok_origin:'0xdc41a2bf843f25c079205f763b5664d503300590329b01772e227bf62adef4dd' ,
     base: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
-    wowok_object: '0xb56d70321b3205e994eb8e7664eabc91f361a55d75f363a321c8d4cf012fd6b2',
-    entity_object: '0x33881b1d2a65886c3068917a20d849e3956771df1bceb7a05678e40bcff30aa2',
+    wowok_object: '0x346ad6492d083d7a345f233e4af16f451bbd2307cdf7b100faa3bc2a9c8dc8d9',
+    entity_object: '0xd2d1b91a348300915b3213c30310fbf2f112c6b2b273096ca78fd85f7c9b8217',
     treasury_cap:'0x538cf8f32d59f58c0450a3a97c1eeed3096f4ce63e07e0bdf343a5cc1464887c',
 }
 const MAINNET = {
@@ -323,7 +322,6 @@ export class Protocol {
     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}`};
     

package/src/resource.ts

@@ -46,15 +46,34 @@ export class Resource {
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
         });
     }
-    add(name:string, object:string[])  {
-        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add');
-        if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'add');
+    add(name:string, object:string[] | TransactionResult[])  {
+        if (object.length === 0) return ;
+        var bString = false;
+
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add.name');
+        if (!IsValidArray(object, (item:any) => {
+            if (typeof(item) === 'string') {
+                bString = true;
+                return IsValidAddress(item)
+            }
+            return true;
+        })) {
+            ERROR(Errors.IsValidArray, 'add.object');
+        }
 
-        this.txb.moveCall({
-            target:Protocol.Instance().ResourceFn('add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
-                this.txb.pure.vector('address', object)]
-        });
+        if (bString) {
+            this.txb.moveCall({
+                target:Protocol.Instance().ResourceFn('add')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
+                    this.txb.pure.vector('address', object as string[])]
+            });            
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ResourceFn('add')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
+                    this.txb.makeMoveVec({elements:object as TransactionResult[], type:'address'})]
+            });   
+        }
     }
 
     add2(object:TxbObject, name:string[])  {

package/src/reward.ts

@@ -264,14 +264,14 @@ export class Reward {
         }
     }
 
-    deposit(rewards:(TransactionResult | TransactionArgument)[])  {
-        if (!rewards || !Protocol.IsValidObjects(rewards)) {
+    deposit(objects:(TransactionResult | TransactionArgument)[])  {
+        if (!objects || !Protocol.IsValidObjects(objects)) {
             ERROR(Errors.IsValidArray)
         }
 
         this.txb.moveCall({
             target:Protocol.Instance().RewardFn('deposit') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.makeMoveVec({elements:array_unique(rewards)})], //@
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.makeMoveVec({elements:array_unique(objects)})], //@
             typeArguments:[this.earnest_type]
         })
     }

package/src/treasury.ts

@@ -4,6 +4,13 @@ import { FnCallType, Protocol, PassportObject, PermissionObject, TreasuryAddress
 import { IsValidDesription, IsValidU64, IsValidAddress, IsValidArgType, IsValidArray, parseObjectType} from './utils'
 import { Errors, ERROR}  from './exception'
 
+export enum WithdrawMode {
+    PERMISSION = 0,
+    GUARD_ONLY_AND_IMMUTABLE = 1,
+    BOTH_PERMISSION_AND_GUARD = 2,
+}
+
+
 export interface DepositParam {
     coin: CoinObject,
     index: bigint,
@@ -22,6 +29,7 @@ export interface WithdrawParam {
     remark: string,
     for_object?: string,
     for_guard?: string,
+    withdraw_guard?: string,
 }
 export class Treasury {
     protected token_type;
@@ -44,8 +52,7 @@ export class Treasury {
         this.txb = txb;
         this.object = '';
     }
-    static New(txb:TransactionBlock, token_type:string, permission:PermissionObject, description:string, 
-        bFreeDeposit:boolean=false, passport?:PassportObject) : Treasury {
+    static New(txb:TransactionBlock, token_type:string, permission:PermissionObject, description:string, passport?:PassportObject) : Treasury {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects, 'Treasury.New permission, bounty');
         }
@@ -60,13 +67,13 @@ export class Treasury {
         if (passport) {
             d.object = txb.moveCall({
                 target:Protocol.Instance().TreasuryFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure.bool(bFreeDeposit), txb.pure.string(description),  Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[passport, txb.pure.string(description),  Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[token_type],
             })        
         } else {
             d.object = txb.moveCall({
                 target:Protocol.Instance().TreasuryFn('new') as FnCallType,
-                arguments:[txb.pure.bool(bFreeDeposit), txb.pure.string(description),  Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure.string(description),  Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[token_type],
             })        
         }
@@ -89,24 +96,47 @@ export class Treasury {
         }) 
     }
     
-    set_free_deposit(bFreeDeposit:boolean, passport?:PassportObject)  {
+    set_deposit_guard(guard?:string, passport?:PassportObject)  {
+        if (guard && !IsValidAddress(guard)) {
+            ERROR(Errors.IsValidAddress, 'set_deposit_guard.guard')
+        }
+
         if (passport) {
-            this.txb.moveCall({
-                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],
-            })
+            if (guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('deposit_guard_set_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
+                        this.txb.object(guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })                
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('deposit_guard_none_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })           
+            }
         } else {
-            this.txb.moveCall({
-                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],
-            })            
+            if (guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('deposit_guard_set') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                        this.txb.object(guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })                
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('deposit_guard_none') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })           
+            }        
         }
     }
     
-    deposit(param:DepositParam, bFreeDeposit:boolean=false, passport?:PassportObject) :TxbObject {
+    deposit(param:DepositParam, passport?:PassportObject) :TxbObject {
         if (!Protocol.IsValidObjects([param.coin])) {
             ERROR(Errors.IsValidObjects, 'deposit.param.coin')
         }
@@ -126,76 +156,59 @@ export class Treasury {
         const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
 
-        if (bFreeDeposit) {
+        if (passport) {
             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)],
+                    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('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)],
+                    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 (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],
-                    })  
-                }
+            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 {
-                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],
-                    })  
-                }
+                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('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)],
+                    Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
             })
         } else {
             return this.txb.moveCall({
                 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)],
+                    Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.token_type],
             })
         }
@@ -218,47 +231,73 @@ export class Treasury {
         if (param?.for_object && !IsValidAddress(param.for_object)) {
             ERROR(Errors.IsValidAddress, 'withdraw.param.for_object')
         }
+        if (param?.withdraw_guard && !IsValidAddress(param.withdraw_guard)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.withdraw_guard')
+        }
+        if (param?.withdraw_guard && !passport) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.withdraw_guard')
+        }
 
         const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
 
-        if (passport) {
+        if (param.withdraw_guard && passport) { //@ dont need passport, use withdraw guard!
             if (param.for_guard) {
                 return this.txb.moveCall({
-                    target:Protocol.Instance().TreasuryFn('withdraw_forGuard_with_passport') as FnCallType,
+                    target:Protocol.Instance().TreasuryFn('withdraw_useGuard_forGuard') 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)],
+                        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), this.txb.object(param.withdraw_guard)],
                     typeArguments:[this.token_type],
                 })
             } else {
                 return this.txb.moveCall({
-                    target:Protocol.Instance().TreasuryFn('withdraw_with_passport') as FnCallType,
+                    target:Protocol.Instance().TreasuryFn('withdraw_useGuard') 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)],
+                        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), this.txb.object(param.withdraw_guard)],
                     typeArguments:[this.token_type],
                 })
             }
         } else {
-            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],
-                })
+            if (passport) {
+                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 {
-                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],
-                })
-            }
+                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],
+                    })
+                }
+            }            
         }
     }
 
@@ -283,6 +322,90 @@ export class Treasury {
         }
     }
     
+    set_withdraw_mode(mode: WithdrawMode, passport?: PassportObject)  {
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('withdraw_mode_set_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u8(mode), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })   
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('withdraw_mode_set') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u8(mode), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })   
+        }
+    }
+
+    add_withdraw_guard(guard:string, amount:bigint, passport?:PassportObject) {
+        if (!IsValidAddress(guard)) {
+            ERROR(Errors.IsValidAddress, 'add_withdraw_guard.guard')
+        }
+
+        if (!IsValidU64(amount)) {
+            ERROR(Errors.IsValidU64, 'add_withdraw_guard.amount')
+        }
+
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('withdraw_guard_add_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(guard), this.txb.pure.u64(amount),
+                    Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })   
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('withdraw_guard_add') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(guard), this.txb.pure.u64(amount),
+                    Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })    
+        }
+    }
+
+    remove_withdraw_guard(guard:string[], removeall?:boolean, passport?:PassportObject) {
+        if (guard.length === 0 && !removeall) return ;
+
+        if (!IsValidArray(guard, IsValidAddress)) {
+            ERROR(Errors.IsValidArray, 'add_withdraw_guard.guard')
+        }
+
+        if (passport) {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_guard_remove_all_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object),
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })   
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_guard_remove_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', guard),
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })   
+            }
+        } else {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_guard_remove_all') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object),
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })   
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().TreasuryFn('withdraw_guard_remove') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', guard),
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.token_type],
+                })   
+            }
+        }
+    }
+
     change_permission(new_permission:PermissionObject)  {
         if (!Protocol.IsValidObjects([new_permission])) {
             ERROR(Errors.IsValidObjects, 'change_permission.new_permission')
@@ -302,5 +425,6 @@ export class Treasury {
     static OP_WITHDRAW = 0;
     static OP_DEPOSIT = 1;
     static OP_RECEIVE = 2;
+    static MAX_WITHDRAW_GUARD_COUNT = 16;
 }
 

package/src/withholding.ts

@@ -1,167 +0,0 @@
-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;
-}