wowok 1.5.38 → 1.5.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.5.38",
+  "version": "1.5.40",
   "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/arbitration.ts

@@ -1,7 +1,7 @@
 import { IsValidArray,  array_unique, IsValidTokenType, IsValidDesription, parseObjectType,
     IsValidAddress, IsValidEndpoint, IsValidU64, IsValidName, } from './utils'
 import { FnCallType, GuardObject, PassportObject, PermissionObject, CoinObject, Protocol,
-    TxbObject, ArbitrationAddress, OrderObject, ArbObject} from './protocol';
+    TxbObject, ArbitrationAddress, OrderObject, ArbObject, PaymentAddress, TreasuryObject} from './protocol';
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
 
@@ -30,6 +30,14 @@ export interface Dispute {
     fee?: CoinObject,
 }
 
+export interface WithdrawFee {
+    treasury: TreasuryObject,
+    index: bigint,
+    remark: string,
+    for_object?: string,
+    for_guard?: GuardObject,
+}
+
 export class Arbitration {
     protected pay_token_type;
     protected permission;
@@ -52,8 +60,8 @@ export class Arbitration {
         return s
     }
     static New(txb: TransactionBlock, token_type:string, permission:PermissionObject, description:string, 
-        fee:bigint, passport?:PassportObject) : Arbitration {
-        if (!Protocol.IsValidObjects([permission])) {
+        fee:bigint, withdrawTreasury:TreasuryObject, passport?:PassportObject) : Arbitration {
+        if (!Protocol.IsValidObjects([permission, withdrawTreasury])) {
             ERROR(Errors.IsValidObjects)
         }
         if (!IsValidTokenType(token_type)) {
@@ -72,13 +80,13 @@ export class Arbitration {
         if (passport) {
             obj.object = txb.moveCall({
                 target:Protocol.Instance().ArbitrationFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure.string(description), txb.pure.u64(fee), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[passport, txb.pure.string(description), txb.pure.u64(fee), txb.object(withdrawTreasury), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[pay_token_type],
             })
         } else {
             obj.object = txb.moveCall({
                 target:Protocol.Instance().ArbitrationFn('new') as FnCallType,
-                arguments:[txb.pure.string(description), txb.pure.u64(fee), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure.string(description), txb.pure.u64(fee), txb.object(withdrawTreasury), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[pay_token_type],
             })
         }
@@ -353,22 +361,78 @@ export class Arbitration {
         }
     }
 
-    withdraw_fee(arb:ArbObject, passport?:PassportObject) {
-        if (!Protocol.IsValidObjects([arb])) {
-            ERROR(Errors.IsValidObjects, 'withdraw_fee.arb')
+    withdraw_fee(arb:ArbObject, param:WithdrawFee,  passport?:PassportObject) : PaymentAddress {
+        if (!Protocol.IsValidObjects([arb, param.treasury])) {
+            ERROR(Errors.IsValidObjects, 'withdraw_fee.arb or treasury')
+        }
+        if (param?.for_guard && !Protocol.IsValidObjects([param.for_guard])) {
+            ERROR(Errors.IsValidObjects, 'withdraw_fee.param.for_guard')
+        }
+        if (param?.for_object && !IsValidAddress(param.for_object)) {
+            ERROR(Errors.IsValidAddress, 'withdraw_fee.param.for_object')
+        }
+        if (!IsValidDesription(param.remark)) {
+            ERROR(Errors.IsValidDesription, 'withdraw_fee.param.remark')
+        }
+        if (!IsValidU64(param.index)) {
+            ERROR(Errors.IsValidU64, 'withdraw_fee.param.index')
+        }
+        const for_obj = this.txb.pure.option('address', param.for_object ?  param.for_object : undefined);
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+        if (passport) {
+            if (param.for_guard) {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('withdraw_forGuard_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(arb), 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 {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('withdraw_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(arb), 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]
+                })                
+            }
+        } else {
+            if (param.for_guard) {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('withdraw_forGuard') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(arb), 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 {
+                return this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('withdraw') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(arb), 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_withdrawTreasury(treasury:TreasuryObject, passport?:PassportObject) {
+        if (!Protocol.IsValidObjects([treasury])) {
+            ERROR(Errors.IsValidObjects, 'set_withdrawTreasury.treasury')
         }
         if (passport) {
             this.txb.moveCall({
-                target:Protocol.Instance().ArbitrationFn('withdraw_with_passport') as FnCallType,
+                target:Protocol.Instance().ArbitrationFn('withdraw_treasury_set_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.object(arb), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.object(treasury), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         } else {
             this.txb.moveCall({
-                target:Protocol.Instance().ArbitrationFn('withdraw') as FnCallType,
+                target:Protocol.Instance().ArbitrationFn('withdraw_treasury_set') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.object(arb), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.object(treasury), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         }
@@ -443,6 +507,10 @@ export class Arbitration {
     static parseArbObjectType = (chain_type:string | undefined | null) : string =>  {
         return parseObjectType(chain_type, 'arb::Arb<')
     }
+
+    static queryArbVoted = () => {
+        
+    }
     static MAX_PROPOSITION_COUNT = 16;
     static MAX_VOTING_GUARD_COUNT = 16;
 }

package/src/guard.ts

@@ -340,6 +340,7 @@ export class Guard {
         [MODULES.arbitration, 'Number of Voting Guard', 1507, [], ValueType.TYPE_U64, 'Number of voting guards.', []], 
         [MODULES.arbitration, 'Has Voting Guard', 1508, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Has the voting Guard added?', ['guard address']], 
         [MODULES.arbitration, 'Voting Weight', 1509, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Voting weight of the voting Guard.', ['guard address']], 
+        [MODULES.arbitration, 'Treasury', 1510, [], ValueType.TYPE_ADDRESS, 'The address of the Treasury where fees was collected at the time of withdrawal.', []], 
 
         [MODULES.arb, 'Order', 1600, [], ValueType.TYPE_ADDRESS, 'Order under arbitration.', []], 
         [MODULES.arb, 'Arbitration', 1601, [], ValueType.TYPE_ADDRESS, "Arbitration object address.", []], 

package/src/payment.ts

@@ -50,7 +50,7 @@ export function create_payment(txb:TransactionBlock, pay_token_type:string, para
         })                
     } else {
         return txb.moveCall({
-            target:Protocol.Instance().PaymentFn('new') as FnCallType,
+            target:Protocol.Instance().PaymentFn('create') as FnCallType,
             arguments:[txb.pure.vector('address', param.receiver.map((i)=>i.address)), txb.makeMoveVec({elements:param.receiver.map((i)=>i.coin)}), 
                 obj, txb.pure.u64(param.business_index), txb.pure.string(param.business_remark), txb.object(clock)],
             typeArguments:[pay_token_type],

package/src/permission.ts

@@ -98,6 +98,7 @@ export enum PermissionIndex {
     arbitration_vote = 807,
     arbitration_arbitration = 808,
     arbitration_withdraw = 809,
+    arbitration_treasury = 810,
     
     user_defined_start = 1000,
 }
@@ -217,6 +218,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     {index:PermissionIndex.arbitration_voting_guard, name: 'Voting Guard', description:'Add/Remove voting Guard', module: 'arbitration'},
     {index:PermissionIndex.arbitration_vote, name: 'Vote', description:'Vote on the application for arbitration', module: 'arbitration'},
     {index:PermissionIndex.arbitration_withdraw, name: 'Withdraw', description:'Withdraw the arbitration fee', module: 'arbitration'},
+    {index:PermissionIndex.arbitration_treasury, name: 'Withdraw', description:'Set Treasury that fees was collected at the time of withdrawal', module: 'arbitration'},
 ]
 
 export type PermissionIndexType = PermissionIndex | number;

package/src/protocol.ts

@@ -220,13 +220,13 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x10a543f1d692c9813d3dfebea75d9ead46a1927c4fbb2d6e646f1aaa3b9ee6bb",
-    wowok_origin:'0x10a543f1d692c9813d3dfebea75d9ead46a1927c4fbb2d6e646f1aaa3b9ee6bb' ,
+    wowok: "0xfa33358cf5f883038d124855567972241cd7036381fbc150a2208ab0e5939621",
+    wowok_origin:'0xfa33358cf5f883038d124855567972241cd7036381fbc150a2208ab0e5939621' ,
     base: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
     base_origin: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
 
-    wowok_object: '0x08c8a98236e0f1dd233722391a8178336ea5615498fe2b459daa11e8d4a01367',
-    entity_object: '0x5fc1554d71c5f2fe3a3101200dd19a0e51869ddd6379fd7e8f8ef72339cfd021',
+    wowok_object: '0x459ed2fd2ad4aac9fd417d50584fae607ee557508dcb9b9f55722e0d18ed81ab',
+    entity_object: '0xfeb95d277598ebb8a358bfda3c62a32d7622de9af7ec3219e67c5749e020f12b',
     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) {

package/src/treasury.ts

@@ -154,7 +154,7 @@ export class Treasury {
             ERROR(Errors.InvalidParam, 'deposit.param.index')
         }
 
-        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
+        const for_obj = this.txb.pure.option('address', param.for_object ? param.for_object: undefined);
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
             if (param.for_guard) {
@@ -240,7 +240,7 @@ export class Treasury {
             ERROR(Errors.IsValidAddress, 'withdraw.param.withdraw_guard')
         }
 
-        const for_obj = this.txb.pure.option('address', param.for_object ?? undefined);
+        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.withdraw_guard && passport) { //@ dont need passport, use withdraw guard!
@@ -290,7 +290,6 @@ export class Treasury {
                         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)),