wowok 1.4.21 → 1.4.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.4.21",
+  "version": "1.4.23",
   "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

@@ -54,7 +54,7 @@ export class Guard {
             target: Protocol.Instance().GuardFn('new') as FnCallType,
             arguments: [txb.pure.string(description), txb.pure.vector('u8', [].slice.call(input.reverse()))],  
         });
-        console.log(constants)
+
         constants?.forEach((v, k) => {
             if (v.bWitness) {
                 const n = new Uint8Array(1); n.set([v.type], 0);
@@ -238,6 +238,29 @@ export class Guard {
         [MODULES.wowok, 'Grantor Expired Time', 907, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The expiration time of a grantor.', ['address']], 
         [MODULES.wowok, 'Grantee Object for Grantor', 908, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'Grantee repository address of a grantor.', ['address']], 
     
+        [MODULES.vote, 'Permission', 1101, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []],       
+        [MODULES.vote, 'Be Voting', 1102, [], ValueType.TYPE_BOOL, 'Whether to start voting and options will not be changed?', []],
+        [MODULES.vote, 'Deadline Locked', 1103, [], ValueType.TYPE_BOOL, 'Whether the deadline cannot be modified?', []],   
+        [MODULES.vote, 'Vote-Guard Locked', 1104, [], ValueType.TYPE_BOOL, 'Whether the Guard for voting cannot be modified?', []],   
+        [MODULES.vote, 'Max Choice Count', 1105, [], ValueType.TYPE_U8, 'The maximum number of options that can be selected in one vote.', []],       
+        [MODULES.vote, 'Deadline', 1106, [], ValueType.TYPE_U64, 'Deadline for voting.', []],
+        [MODULES.vote, 'Has Reference', 1107, [], ValueType.TYPE_BOOL, 'Whether to vote for a reference Object?', []],   
+        [MODULES.vote, 'Reference', 1108, [], ValueType.TYPE_ADDRESS, 'Reference Object that voting for.', []], 
+        [MODULES.vote, 'Has Vote-Guard', 1109, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a certain Guard included in the Vote-Guard settings?', ['guard address']],
+        [MODULES.vote, 'Vote-Guard Wight', 1110, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The voting weight corresponding to the Vote-Guard.', ['guard address']],   
+        [MODULES.vote, 'Has Voted by Address', 1111, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address has already voted?', ['address']], 
+        [MODULES.vote, 'Voted Weight by Address', 1112, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The weight of whether an address has been voted on.', ['adddress']], 
+        [MODULES.vote, 'Has Option', 1113, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option is included?', ['option name']],
+        [MODULES.vote, 'Has Object of Option', 1114, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option refers to an object?', ['option name']],   
+        [MODULES.vote, 'Option Object', 1115, [ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The object referenced by a voting option.', ['option name']], 
+        [MODULES.vote, 'Option Counts', 1116, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of votes for the voting option.', ['option name']], 
+        [MODULES.vote, 'Option Votes', 1117, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of voted addresses for the voting option.', ['option name']], 
+        [MODULES.vote, 'Address Count Voted', 1118, [], ValueType.TYPE_U64, 'Total number of addresses voted.', []],   
+        [MODULES.vote, 'Top1 Option by Addresses', 1119, [], ValueType.TYPE_STRING, 'The name of the voting option ranked first by the number of voting addresses.', []], 
+        [MODULES.vote, 'Top1 Counts by Addresses', 1120, [], ValueType.TYPE_U64, 'Number of votes for the top voting option by number of voting addresses.', []], 
+        [MODULES.vote, 'Top1 Option by Votes', 1121, [], ValueType.TYPE_STRING, 'The name of the voting option ranked first by the number of votes.', []], 
+        [MODULES.vote, 'Top1 Counts by Votes', 1122, [], ValueType.TYPE_U64, 'Number of votes for the top voting option by number of votes.', []], 
+
         [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']], 
@@ -253,52 +276,30 @@ export class Guard {
         [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.withholding, 'Has Deposited', 1300, [], ValueType.TYPE_BOOL, 'Whether assets have been deposited?' , []], 
+        [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, 'Withdrawal Guard', 1307, [], ValueType.TYPE_ADDRESS, 'Withdrawal Guard address.', []], 
+        [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, 'Withdrawal Time', 1309, [], ValueType.TYPE_U64, 'Withdrawal time.' , []], 
-        [MODULES.withholding, 'Depositor Address', 1310, [], ValueType.TYPE_ADDRESS, 'Depositor address.', []], 
-        [MODULES.withholding, 'Withdrawal Address', 1311, [], ValueType.TYPE_ADDRESS, 'Withdrawal address.', []], 
-        [MODULES.withholding, 'From Treasury', 1312, [], ValueType.TYPE_BOOL, 'Is it the deposit from a treasury?', []], 
-        [MODULES.withholding, 'Treasury Address', 1314, [], ValueType.TYPE_ADDRESS, 'Treasury address that asserts deposited.', ['address']], 
+        [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.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, 'Take Flow', 1404, [], ValueType.TYPE_U128, 'Treasury outflow 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, 'Take 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.vote, 'Permission', 171, [], ValueType.TYPE_ADDRESS],       
-        [MODULES.vote, 'Options Locked', 172, [], ValueType.TYPE_BOOL],
-        [MODULES.vote, 'Deadline Locked', 173, [], ValueType.TYPE_BOOL],   
-        [MODULES.vote, 'Vote-Guard Locked', 174, [], ValueType.TYPE_BOOL],   
-        [MODULES.vote, 'Max Choice Count', 175, [], ValueType.TYPE_U8],       
-        [MODULES.vote, 'Deadline', 176, [], ValueType.TYPE_U64],
-        [MODULES.vote, 'Has Reference', 177, [], ValueType.TYPE_BOOL],   
-        [MODULES.vote, 'Reference', 178, [], ValueType.TYPE_ADDRESS], 
-        [MODULES.vote, 'Has Vote-Guard', 179, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL],
-        [MODULES.vote, 'Vote-Guard', 180, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],   
-        [MODULES.vote, 'Has Voted by Address', 181, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL], 
-        [MODULES.vote, 'Voted Weight by Address', 182, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Has Option', 183, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],
-        [MODULES.vote, 'Has Object of Option', 184, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL],   
-        [MODULES.vote, 'Option Object', 185, [ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS], 
-        [MODULES.vote, 'Option Count', 186, [ValueType.TYPE_STRING], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Option Votes', 187, [ValueType.TYPE_STRING], ValueType.TYPE_U64],
-        [MODULES.vote, 'Address Count Voted', 188, [], ValueType.TYPE_U64],   
-        [MODULES.vote, 'Top1 Option by Addresses', 189, [], ValueType.TYPE_STRING], 
-        [MODULES.vote, 'Top1 Count by Addresses', 190, [], ValueType.TYPE_U64], 
-        [MODULES.vote, 'Top1 Option by Votes', 191, [], ValueType.TYPE_STRING], 
-        [MODULES.vote, 'Top1 Count by Votes', 192, [], ValueType.TYPE_U64], */
+        [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']], 
     ];
 
     static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);

package/src/index.ts

@@ -13,4 +13,5 @@ export * from './service'
 export * from './graphql'
 export * from './entity'
 export * from './wowok'
-export * from './resource'
+export * from './resource'
+export * from './treasury'

package/src/machine.ts

@@ -65,7 +65,6 @@ export class Machine {
 
         let m = new Machine(txb, permission);   
         let ep = txb.pure.option('string', endpoint ? endpoint : undefined);
-    
         if (passport) {
             m.object = txb.moveCall({
                 target:Protocol.Instance().MachineFn('new_with_passport') as FnCallType,

package/src/permission.ts

@@ -81,7 +81,9 @@ export enum PermissionIndex {
 
     treasury = 700,
     treasury_deposit = 701,
-    treasury_take = 702,
+    treasury_withdraw = 702,
+    treasury_free_deposit_set = 703,
+    treasury_descritption = 704, 
     user_defined_start = 1000,
 }
 
@@ -182,7 +184,9 @@ 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_take, name: 'Take', description:'Take out coins', 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'},
 ]
 
 export type PermissionIndexType = PermissionIndex | number;

package/src/protocol.ts

@@ -211,10 +211,10 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    package: "0x61dad08ebbda7d4f38223e222a2dcc18cec644d99c66937cde65dd99a9ba93b1",
-    wowok_object: '0xed0a7c40db1f8de42e4dd5ecca2e7912701dee0fe9f7b6fe7ebd7205133a80b7',
-    entity_object: '0x4a4850bf062bb29fec3b64de337db02f7ccee0ae13b85f287ee5850a568ae330',
-    treasury_cap:'0xb33d469f8164eefbf02b260e02194faab5bfad2acafd36088e1e64302bbcd797',
+    package: "0xf108d64c8143ec040da0d5538e834a67f0a9c661f92011195b60f51b3bc33a46",
+    wowok_object: '0xc4fc2a42a5fbcfc68b3d8ac079e4d5a07f637c541e0183446a9da655965cda5e',
+    entity_object: '0x8bbab9023092dc89c3c60c766b204c0dfbe3da46a2de486d8ab92ba91a4c905f',
+    treasury_cap:'0x07e7b3c355b63bade82c1e0e2653e655a1b20da6cc531db5707ad1292fd418e4',
 }
 const MAINNET = {
     package: "",
@@ -311,6 +311,7 @@ export class Protocol {
     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}`};
     
     Query = async (objects: Query_Param[], options:SuiObjectDataOptions={showContent:true}) : Promise<SuiObjectResponse[]> => {
         const client =  new SuiClient({ url: this.NetworkUrl() });  
@@ -465,7 +466,7 @@ export class RpcResultParser {
         return names;
     }
     static objectids_from_response = (protocol:Protocol, response:SuiTransactionBlockResponse, concat_result?:Map<string, TxbObject[]>): Map<string, TxbObject[]> => {
-        // console.log(response)
+        //console.log(response)
         let ret = new Map<string, string[]>();
         if (response?.objectChanges) {
             response.objectChanges.forEach((change) => {

package/src/service.ts

@@ -626,15 +626,21 @@ export class Service {
     }
 
     // support both withdraw guard and permission guard
-    withdraw(order:OrderObject, passport?:PassportObject) {
+    withdraw(order:OrderObject, withdraw_guard?:string, passport?:PassportObject) {
         if (!Protocol.IsValidObjects([order]))  {
-            ERROR(Errors.IsValidObjects, 'order')
+            ERROR(Errors.IsValidObjects, 'withdraw.order')
         }
-        
-        if (passport) {
+        if (withdraw_guard && !IsValidAddress(withdraw_guard)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.withdraw_guard')
+        }
+        if (passport && !withdraw_guard) {
+            ERROR(Errors.InvalidParam, 'withdraw.passport need withdraw_guard')
+        }
+        if (passport && withdraw_guard) {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('withdraw_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), 
+                    this.txb.object(withdraw_guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })        
         } else {
@@ -868,15 +874,20 @@ export class Service {
         }    
     }
 
-    refund(order:OrderObject, passport?:PassportObject) {
+    refund(order:OrderObject, refund_guard?:string, passport?:PassportObject) {
         if (!Protocol.IsValidObjects([order])) {
-            ERROR(Errors.IsValidObjects, 'order')
+            ERROR(Errors.IsValidObjects, 'refund.order')
         }
-
-        if (passport) {
+        if (refund_guard && !IsValidAddress(refund_guard)) {
+            ERROR(Errors.IsValidAddress, 'refund.refund_guard')
+        }
+        if (passport && !refund_guard) {
+            ERROR(Errors.InvalidParam, 'refund.passport need refund_guard')
+        }
+        if (passport && refund_guard) {
             this.txb.moveCall({
             target:Protocol.Instance().ServiceFn('refund_with_passport') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), passport],
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), this.txb.object(refund_guard), passport],
             typeArguments:[this.pay_token_type]
             })               
         } else {

package/src/treasury.ts

@@ -0,0 +1,239 @@
+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 { Errors, ERROR}  from './exception'
+
+export class Treasury {
+    protected token_type;
+    protected permission ;
+    protected object : TxbObject;
+    protected txb;
+
+    get_token_type() {  return this.token_type }
+    get_object() { return this.object }
+
+    static From(txb:TransactionBlock, token_type:string, permission:PermissionObject, object:TxbObject) : Treasury {
+        let d = new Treasury(txb,  token_type, permission)
+        d.object = Protocol.TXB_OBJECT(txb, object)
+        return d
+    }   
+
+    private constructor(txb:TransactionBlock, token_type:string, permission:PermissionObject) {
+        this.token_type = token_type;
+        this.permission = permission;
+        this.txb = txb;
+        this.object = '';
+    }
+    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');
+        }
+        if (!IsValidDesription(description)) {
+            ERROR(Errors.IsValidDesription);
+        } 
+        if (!IsValidArgType(token_type)) {
+            ERROR(Errors.IsValidArgType, token_type);
+        }
+        
+        let  d = new Treasury(txb, token_type, permission);
+        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)],
+                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)],
+                typeArguments:[token_type],
+            })        
+        }
+        return d
+    }
+
+    launch() : DemandAddress {
+        return this.txb.moveCall({
+            target:Protocol.Instance().TreasuryFn('create') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)],
+            typeArguments:[this.token_type],
+        })
+    }
+    
+    destroy() {
+        this.txb.moveCall({
+            target:Protocol.Instance().TreasuryFn('destroy') as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
+            typeArguments:[this.token_type]
+        }) 
+    }
+    
+    set_free_deposits(bFreeDeposit:boolean, passport?:PassportObject)  {
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('free_deposits_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,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(bFreeDeposit), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })            
+        }
+    }
+    
+    deposit(coin:CoinObject, tips:string, for_object?:string, index?:number, from_object?:string, passport?:PassportObject) :TxbObject {
+        if (!Protocol.IsValidObjects([coin])) {
+            ERROR(Errors.IsValidObjects, 'deposit.coin')
+        }
+        if (!IsValidDesription(tips)) {
+            ERROR(Errors.IsValidDesription, 'deposit.tips')
+        }
+        if (for_object && !IsValidAddress(for_object)) {
+            ERROR(Errors.IsValidAddress, 'deposit.tips')
+        }
+        if (from_object && !IsValidAddress(from_object)) {
+            ERROR(Errors.IsValidAddress, 'deposit.from_object')
+        }
+        if (index !== undefined && !IsValidU64(index)) {
+            ERROR(Errors.InvalidParam, '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);
+
+        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)],
+                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)],
+                typeArguments:[this.token_type],
+            })  
+        }
+    }
+
+    free_deposit(coin:CoinObject, tips:string, for_object?:string, index?:number, from_object?:string) : TxbObject  {
+        if (!Protocol.IsValidObjects([coin])) {
+            ERROR(Errors.IsValidObjects, 'free_deposit.coin')
+        }
+        if (!IsValidDesription(tips)) {
+            ERROR(Errors.IsValidDesription, 'free_deposit.tips')
+        }
+        if (for_object && !IsValidAddress(for_object)) {
+            ERROR(Errors.IsValidAddress, 'free_deposit.for_object')
+        }
+        if (from_object && !IsValidAddress(from_object)) {
+            ERROR(Errors.IsValidAddress, 'free_deposit.from_object')
+        }
+        if (index !== undefined && !IsValidU64(index)) {
+            ERROR(Errors.InvalidParam, 'free_deposit.index')
+        }
+        const for_obj = this.txb.pure.option('address', for_object ?? undefined);
+        const idx = this.txb.pure.option('u64', index ?? undefined);
+        const from_obj = this.txb.pure.option('address', from_object ?? undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        return this.txb.moveCall({
+            target:Protocol.Instance().TreasuryFn('deposit2') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, coin), 
+                this.txb.pure.string(tips), for_obj, idx, from_obj, this.txb.object(clock)],
+            typeArguments:[this.token_type],
+        })  
+    }
+    
+    withdraw(amount:number, tips:string, for_object?:string, index?:number, to_object?:string, passport?:PassportObject) : CoinObject {
+        if (!IsValidU64(amount)) {
+            ERROR(Errors.IsValidObjects, 'withdraw.amount')
+        }
+        if (!IsValidDesription(tips)) {
+            ERROR(Errors.IsValidDesription, 'withdraw.tips')
+        }
+        if (for_object && !IsValidAddress(for_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.for_object')
+        }
+        if (to_object && !IsValidAddress(to_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.to_object')
+        }
+        if (index !== undefined && !IsValidU64(index)) {
+            ERROR(Errors.InvalidParam, 'withdraw.index')
+        }
+        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 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],
+            })
+        } 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],
+            })
+        }
+    }
+
+    set_description(description:string, passport?:PassportObject) {
+        if (!IsValidDesription(description)) {
+            ERROR(Errors.IsValidDesription, 'set_description.description');
+        }
+    
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('description_set_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description), 
+                    Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.token_type],
+            })    
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().TreasuryFn('description_set') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description), 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')
+        }
+    
+        this.txb.moveCall({
+            target:Protocol.Instance().TreasuryFn('permission_set') as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission), Protocol.TXB_OBJECT(this.txb, new_permission)],
+            typeArguments:[this.token_type]            
+        })    
+        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 '';
+    }
+}
+

package/src/vote.ts

@@ -4,8 +4,7 @@ import { ERROR, Errors } from './exception';
 import { ValueType } from './protocol';
 import { Transaction as TransactionBlock} from '@mysten/sui/transactions';
 
-export const MAX_AGREES_COUNT = 200;
-export const MAX_CHOICE_COUNT = 200;
+
 
 export type VoteOption = {
     name:string;
@@ -42,7 +41,7 @@ export class Vote {
         if (max_choice_count && !IsValidUintLarge(max_choice_count)) {
             ERROR(Errors.IsValidUint, 'max_choice_count')
         }
-        if (max_choice_count && max_choice_count > MAX_CHOICE_COUNT) {
+        if (max_choice_count && max_choice_count > Vote.MAX_CHOICE_COUNT) {
             ERROR(Errors.InvalidParam, 'max_choice_count')
         }
         if (reference_address && !IsValidAddress(reference_address)) {
@@ -250,7 +249,7 @@ export class Vote {
         }
     }
     set_max_choice_count(max_choice_count:number, passport?:PassportObject)  {
-        if (!IsValidUintLarge(max_choice_count) || max_choice_count > MAX_CHOICE_COUNT) {
+        if (!IsValidUintLarge(max_choice_count) || max_choice_count > Vote.MAX_CHOICE_COUNT) {
             ERROR(Errors.InvalidParam, 'max_choice_count')
         }
 
@@ -333,7 +332,7 @@ export class Vote {
 
     agree(options:string[], passport?:PassportObject)  {
         if (options.length === 0) return;
-        if (options.length > MAX_CHOICE_COUNT) {
+        if (options.length > Vote.MAX_CHOICE_COUNT) {
             ERROR(Errors.InvalidParam, 'agree')
         }
 
@@ -363,4 +362,7 @@ export class Vote {
         })    
         this.permission = new_permission
     }
+
+    static  MAX_AGREES_COUNT = 100;
+    static  MAX_CHOICE_COUNT = 100;
 }