wowok 1.5.39 → 1.5.41

package/package.json

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

@@ -1,6 +1,6 @@
 
 
-import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, TxbObject, GuardObject} from './protocol';
+import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, TxbObject, GuardObject, IsValidOperatorType} from './protocol';
 import { concatenate, array_equal, ValueTypeConvert } from './utils';
 import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase, insertAtHead } from './utils';
 import { ERROR, Errors } from './exception';
@@ -587,11 +587,11 @@ export class GuardMaker {
         return this;
     }
 
-    add_logic(type:OperatorType, logic_count:number=2) : GuardMaker {
+    add_logic(type:OperatorType, logic_count?:number) : GuardMaker {
         var e:any = LogicsInfo.find((v:any) => v[0] === type);
         if (e) { e=e[1] }
 
-        let splice_len = 2;
+        let splice_len = 2; let cur:any;
         let ret = ValueType.TYPE_BOOL;
         switch (type) {
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
@@ -599,26 +599,28 @@ export class GuardMaker {
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
             case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
-                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
-                if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
+                if (!logic_count || logic_count < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = logic_count!;
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                for (let i = 1; i <= splice_len; ++i) {
+                    if (!GuardMaker.match_u256(this.type_validator[this.type_validator.length - i])) { ERROR(Errors.Fail, 'type_validator check:'+e) }
+                }
                 break;
             case OperatorType.TYPE_LOGIC_EQUAL:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
-                if (GuardMaker.match_u256(this.type_validator[this.type_validator.length - 1]) && 
-                    GuardMaker.match_u256(this.type_validator[this.type_validator.length - 2])) {
-                    break;
-                } else if (this.type_validator[this.type_validator.length - 1] === this.type_validator[this.type_validator.length - 2]) {
-                    break;
-                } else {
-                    ERROR(Errors.Fail, 'type_validator check:' + e)  ;
+                if (!logic_count || logic_count < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = logic_count!;
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                cur = this.type_validator[this.type_validator.length - 1];
+                for (let i = 2; i <= splice_len; ++i) {
+                    if (this.type_validator[this.type_validator.length - i] !== cur) ERROR(Errors.Fail, 'type_validator check:' + e)  ;
                 }
                 break;
             case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
-                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:' + e) }
-                if (this.type_validator[this.type_validator.length - 1] !== ValueType.TYPE_STRING || 
-                    this.type_validator[this.type_validator.length - 2] !== ValueType.TYPE_STRING) {
-                        ERROR(Errors.Fail, 'type_validator check:' + e)  ;
+                if (!logic_count || logic_count < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = logic_count!;
+                if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
+                for (let i = 1; i <= splice_len; ++i) {
+                    if (this.type_validator[this.type_validator.length - i] !== ValueType.TYPE_STRING) ERROR(Errors.Fail, 'type_validator check:' + e)  ;
                 }
                 break;
             case OperatorType.TYPE_LOGIC_NOT:
@@ -642,9 +644,12 @@ export class GuardMaker {
             case OperatorType.TYPE_NUMBER_MULTIPLY:
             case OperatorType.TYPE_NUMBER_SUBTRACT:
             case OperatorType.TYPE_NUMBER_MOD:
+                if (!logic_count || logic_count < 2) ERROR(Errors.Fail, 'logic param invalid:'+e);
+                splice_len = logic_count!;
                 if (this.type_validator.length < splice_len)  { ERROR(Errors.Fail, 'type_validator.length:'+e) }
-                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
-                if (!GuardMaker.IsNumberType(this.type_validator[this.type_validator.length -2])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
+                for (let i = 1; i <= splice_len; ++i) {
+                    if(!GuardMaker.match_u256(this.type_validator[this.type_validator.length -1])) { ERROR(Errors.Fail, 'type_validator check:'+e)  }
+                }
                 ret = ValueType.TYPE_U256;
                 break;
             default:
@@ -652,7 +657,7 @@ export class GuardMaker {
         }
 
         this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE 
-        if (type === OperatorType.TYPE_LOGIC_AND || type === OperatorType.TYPE_LOGIC_OR) {
+        if (GuardMaker.is_multi_input_op(type)) {
             this.data.push((Bcs.getInstance().ser(ValueType.TYPE_U8, logic_count))); //@ logics
         }    
         this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack   
@@ -660,10 +665,6 @@ export class GuardMaker {
         return this;
     }
 
-    static IsNumberType(type:Data_Type) : boolean {
-        return (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 || type === ValueType.TYPE_U256)
-    }
-
     hasIdentifier(id:number) : boolean {
         return this.constant.has(id)
     }
@@ -720,6 +721,18 @@ export class GuardMaker {
     static match_u256(type:number) : boolean {
         return (type == ValueType.TYPE_U8 || type == ValueType.TYPE_U64 || type == ValueType.TYPE_U128 || type == ValueType.TYPE_U256);
     }
+    static is_multi_input_op(type:number) : boolean {
+        return (type === OperatorType.TYPE_LOGIC_AS_U256_GREATER || 
+            type === OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL || 
+            type === OperatorType.TYPE_LOGIC_AS_U256_LESSER || 
+            type === OperatorType.TYPE_LOGIC_AS_U256_LESSER ||
+            type === OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL ||
+            type === OperatorType.TYPE_LOGIC_AS_U256_EQUAL ||
+            type === OperatorType.TYPE_LOGIC_EQUAL ||
+            type === OperatorType.TYPE_LOGIC_HAS_SUBSTRING ||
+            type === OperatorType.TYPE_LOGIC_AND ||
+            type === OperatorType.TYPE_LOGIC_OR)
+    }
 }
 
 

package/src/passport.ts

@@ -4,7 +4,7 @@ import { FnCallType, GuardObject, Protocol, ContextType, OperatorType, Data_Type
     ValueType, SER_VALUE, IsValidOperatorType } from './protocol';
 import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray, insertAtHead, readOption, readOptionString } from './utils';
 import { ERROR, Errors } from './exception';
-import { Guard } from './guard';
+import { Guard, GuardMaker } from './guard';
 
 export type Guard_Query_Object = {
     target: FnCallType, // object fnCall
@@ -137,41 +137,33 @@ export class GuardParser {
                     current.ret_type = ValueType.TYPE_U256;
                 }
                 
-                if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
-                for (let i = 0; i < 2; ++i) {
-                    let p = stack.pop() as DeGuardData;
-                    if (!p.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
-                    if (p.ret_type != ValueType.TYPE_U8  && p.ret_type != ValueType.TYPE_U64 &&
-                        p.ret_type != ValueType.TYPE_U128 && p.ret_type != ValueType.TYPE_U256) {
-                            ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
-                    };
+                if (stack.length < current.value || current.value < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                for (let i = 0; i < current.value; ++i) {
+                    var p = stack.pop() as DeGuardData;
+                    if (!p.ret_type || !GuardMaker.match_u256(p.ret_type))  ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
                     current.child.push(p);
                 }
                 stack.push(current);
-                return;
+                return
             case OperatorType.TYPE_LOGIC_EQUAL:
                 current.ret_type = ValueType.TYPE_BOOL;
-                if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
-                var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
-                //console.log(p1); console.log(p2)
-                if (!p1.ret_type || !p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
-                if (p1.ret_type != p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
-
-                current.child.push(p1);
-                current.child.push(p2);
+                if (stack.length < current.value || current.value < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                var p0 = stack.pop() as DeGuardData;
+                for (let i = 1; i < current.value; ++i) {
+                    var p = stack.pop() as DeGuardData;
+                    if (!p.ret_type || (p.ret_type != p0.ret_type))  ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                    current.child.push(p);
+                }
                 stack.push(current);
-                return;
+                return
             case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
                 current.ret_type = ValueType.TYPE_BOOL;
-                if (stack.length < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
-                var p1 = stack.pop() as DeGuardData; var p2 = stack.pop() as DeGuardData;
-                if (!p1.ret_type || !p2.ret_type) ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
-                if (p1.ret_type != ValueType.TYPE_STRING || p2.ret_type != ValueType.TYPE_STRING) {
-                    ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' param type not match');
+                if (stack.length < current.value || current.value < 2) ERROR(Errors.Fail, 'ResolveData: ' + current.type);
+                for (let i = 0; i < current.value; ++i) {
+                    var p = stack.pop() as DeGuardData;
+                    if (!p.ret_type || (p.ret_type != ValueType.TYPE_STRING))  ERROR(Errors.Fail, 'ResolveData: ' + current.type + ' INVALID param type');
+                    current.child.push(p);
                 }
-
-                current.child.push(p1);
-                current.child.push(p2);
                 stack.push(current);
                 return
             case OperatorType.TYPE_LOGIC_AND:
@@ -370,6 +362,9 @@ export class GuardParser {
                 case ContextType.TYPE_SIGNER:
                 case ContextType.TYPE_CLOCK:
                 case ContextType.TYPE_GUARD:
+                case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
+                case OperatorType.TYPE_LOGIC_NOT:
+                    break;
                 case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
                 case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
                 case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
@@ -377,14 +372,11 @@ export class GuardParser {
                 case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
                 case OperatorType.TYPE_LOGIC_EQUAL:
                 case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
-                case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
-                case OperatorType.TYPE_LOGIC_NOT:
                 case OperatorType.TYPE_NUMBER_ADD:
                 case OperatorType.TYPE_NUMBER_DEVIDE:
                 case OperatorType.TYPE_NUMBER_MOD:
                 case OperatorType.TYPE_NUMBER_MULTIPLY:
                 case OperatorType.TYPE_NUMBER_SUBTRACT:
-                    break;    
                 case OperatorType.TYPE_LOGIC_AND: //@ with logics count
                 case OperatorType.TYPE_LOGIC_OR:
                     value = arr.shift()! as number; 

package/src/protocol.ts

@@ -94,17 +94,17 @@ export enum OperatorType {
 }       
 
 export const LogicsInfo = [
-    [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'Unsigned Integer >'],
-    [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'Unsigned Integer >='],
-    [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'Unsigned Integer <'],
-    [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'Unsigned Integer <='],
-    [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'Unsigned Integer ='],
-    [OperatorType.TYPE_LOGIC_EQUAL, 'Equal'],
-    [OperatorType.TYPE_LOGIC_HAS_SUBSTRING, 'Sub String'],
-    [OperatorType.TYPE_LOGIC_ALWAYS_TRUE, 'Always True'], 
-    [OperatorType.TYPE_LOGIC_NOT, 'Not'],
-    [OperatorType.TYPE_LOGIC_AND, 'And'],
-    [OperatorType.TYPE_LOGIC_OR, 'Or'], 
+    [OperatorType.TYPE_LOGIC_AS_U256_GREATER, 'Unsigned Integer >', 'The first item > anything that follows'],
+    [OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL, 'Unsigned Integer >=', 'The first item >= anything that follows'],
+    [OperatorType.TYPE_LOGIC_AS_U256_LESSER, 'Unsigned Integer <', 'The first item < anything that follows'],
+    [OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL, 'Unsigned Integer <=', 'The first item <= anything that follows'],
+    [OperatorType.TYPE_LOGIC_AS_U256_EQUAL, 'Unsigned Integer =', 'The first item = anything that follows'],
+    [OperatorType.TYPE_LOGIC_EQUAL, 'Equal', 'Data and type are exactly equal for all items'],
+    [OperatorType.TYPE_LOGIC_HAS_SUBSTRING, 'Has Sub String', 'The first item contains anything that follows'],
+    [OperatorType.TYPE_LOGIC_ALWAYS_TRUE, 'Always True', 'Always True'], 
+    [OperatorType.TYPE_LOGIC_NOT, 'Not', 'Not operation'],
+    [OperatorType.TYPE_LOGIC_AND, 'And', 'All Items And operations'],
+    [OperatorType.TYPE_LOGIC_OR, 'Or', 'All Items Or operations'], 
 ];
 
 export enum ValueType {
@@ -165,6 +165,7 @@ export enum ContextType {
     TYPE_SIGNER  = 60,
     TYPE_CLOCK = 61,
     TYPE_GUARD = 62, // current guard address
+    TYPE_STACK_ADDRESS = 63, // object queried from current stack top
     TYPE_CONSTANT = 80,
 }
 interface ValueTypeString {
@@ -220,13 +221,13 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x1633497f1d7a9cdb7f8afc619fb25e138dcfa3b04d8685a0b3f266c5f4c33d37",
-    wowok_origin:'0x1633497f1d7a9cdb7f8afc619fb25e138dcfa3b04d8685a0b3f266c5f4c33d37' ,
+    wowok: "0x95541edbae1f167f8679df2bbee57eafaf09cf81230094ffc196e78a0df200e4",
+    wowok_origin:'0x95541edbae1f167f8679df2bbee57eafaf09cf81230094ffc196e78a0df200e4' ,
     base: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
     base_origin: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
 
-    wowok_object: '0x2806f245ec96a33c9dcb1b03c569f262e94f00d8ae9e759f8c8edbcffdb99986',
-    entity_object: '0x2e90eeafd6df01a92704ffc3420f18801626403b322b1a0267bf4d6db268037a',
+    wowok_object: '0x33917cc62420ba654a0d4a0325e4d31778b12b4f736812d7427904e9911abad3',
+    entity_object: '0xf6f8ee1a3bc19288ac1067f77eae6e72bd1887b35a0c7996635eee975d758901',
     treasury_cap:'0x538cf8f32d59f58c0450a3a97c1eeed3096f4ce63e07e0bdf343a5cc1464887c',
 }
 const MAINNET = {

package/src/service.ts

@@ -3,7 +3,8 @@ import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, parseObjectType,
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryObject, MachineObject, ServiceAddress, 
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
     TxbObject,
-    TreasuryObject} from './protocol';
+    TreasuryObject,
+    PaymentAddress} from './protocol';
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
 import { SuiObjectData } from '@mysten/sui/client';
@@ -57,6 +58,14 @@ export type DicountDispatch = {
     count: bigint;
     discount: Service_Discount;
 }
+export interface WithdrawPayee {
+    withdraw_guard: GuardObject;
+    treasury: TreasuryObject,
+    index: bigint,
+    remark: string,
+    for_object?: string,
+    for_guard?: GuardObject,
+}
 
 export type handleDiscountObject = (owner:string, objects:(SuiObjectData|null|undefined)[]) => void;
 export class Service {
@@ -81,8 +90,8 @@ export class Service {
         return s
     }
     static New(txb: TransactionBlock, token_type:string, permission:PermissionObject, description:string, 
-        payee_address:string, passport?:PassportObject) : Service {
-        if (!Protocol.IsValidObjects([permission])) {
+        payee_treasury:TreasuryObject, passport?:PassportObject) : Service {
+        if (!Protocol.IsValidObjects([permission, payee_treasury])) {
             ERROR(Errors.IsValidObjects)
         }
         if (!IsValidTokenType(token_type)) {
@@ -91,9 +100,6 @@ export class Service {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        if (!IsValidAddress(payee_address)) {
-            ERROR(Errors.IsValidAddress, 'payee_address')
-        }
 
         let pay_token_type = token_type;
         let s = new Service(txb, pay_token_type, permission);
@@ -102,13 +108,13 @@ export class Service {
         if (passport) {
             s.object = txb.moveCall({
                 target:Protocol.Instance().ServiceFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure.string(description), txb.pure.address(payee_address), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[passport, txb.pure.string(description), txb.object(payee_treasury), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[pay_token_type],
             })
         } else {
             s.object = txb.moveCall({
                 target:Protocol.Instance().ServiceFn('new') as FnCallType,
-                arguments:[txb.pure.string(description), txb.pure.address(payee_address), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure.string(description), txb.object(payee_treasury), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[pay_token_type],
             })
         }
@@ -281,21 +287,21 @@ export class Service {
         }        
     }
 
-    set_payee(payee:string, passport?:PassportObject)  {
-        if (!IsValidAddress(payee)) {
-            ERROR(Errors.IsValidAddress, 'payee');
+    set_payee(payee:TreasuryObject, passport?:PassportObject)  {
+        if (!Protocol.IsValidObjects([payee])) {
+            ERROR(Errors.IsValidObjects, 'set_payee');
         }
         
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('payee_set_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(payee), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(payee), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('payee_set') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(payee), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(payee), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         }
@@ -622,30 +628,44 @@ export class Service {
     }
 
     // support both withdraw guard and permission guard
-    withdraw(order:OrderObject, withdraw_guard?:string, passport?:PassportObject) {
-        if (!Protocol.IsValidObjects([order]))  {
-            ERROR(Errors.IsValidObjects, 'withdraw.order')
+    // withdraw_guard & passport must BOTH valid.
+    withdraw(order:OrderObject, param:WithdrawPayee, passport:PassportObject) : PaymentAddress {
+        if (!Protocol.IsValidObjects([order, param.treasury, param.withdraw_guard, passport]))  {
+            ERROR(Errors.IsValidObjects,)
         }
-        if (withdraw_guard && !IsValidAddress(withdraw_guard)) {
-            ERROR(Errors.IsValidAddress, 'withdraw.withdraw_guard')
+        if (param?.for_guard && !Protocol.IsValidObjects([param.for_guard])) {
+            ERROR(Errors.IsValidObjects, 'withdraw.param.for_guard')
         }
-        if (passport && !withdraw_guard) {
-            ERROR(Errors.InvalidParam, 'withdraw.passport need withdraw_guard')
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw.param.for_object')
         }
-        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), 
-                    this.txb.object(withdraw_guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
+        if (!IsValidU64(param.index)) {
+            ERROR(Errors.IsValidU64, 'withdraw.param.index')
+        }
+        if (!IsValidDesription(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'withdraw.param.remark')
+        }
+
+        const for_obj = this.txb.pure.option('address', param.for_object ?  param.for_object : undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        if (param.for_guard) {
+            return this.txb.moveCall({
+                target:Protocol.Instance().ServiceFn('withdraw_forGuard_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), this.txb.object(param.withdraw_guard), 
+                    this.txb.object(param.treasury), for_obj, this.txb.object(param.for_guard), this.txb.pure.u64(param.index), this.txb.pure.string(param.remark), 
+                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
-            })        
+            })    
         } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().ServiceFn('withdraw') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), Protocol.TXB_OBJECT(this.txb, this.permission)],
+            return 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), this.txb.object(param.withdraw_guard), 
+                    this.txb.object(param.treasury), for_obj, this.txb.pure.u64(param.index), this.txb.pure.string(param.remark), 
+                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
-            })               
-        }
+            })    
+        }      
     }
 
     set_buy_guard(guard?:GuardObject, passport?:PassportObject) {