wowok 1.5.40 → 1.5.43

package/package.json

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

@@ -67,14 +67,6 @@ export class Demand {
         })
     }
     
-    destroy() {
-        this.txb.moveCall({
-            target:Protocol.Instance().DemandFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-            typeArguments:[this.bounty_type]
-        }) 
-    }
-    
     refund(passport?:PassportObject)  {
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
@@ -98,19 +90,18 @@ export class Demand {
         if (!IsValidU64(time)) {
             ERROR(Errors.IsValidUint, 'time');
         }
-        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().DemandFn('time_expand_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(minutes_duration),
-                    this.txb.pure.u64(time), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.pure.u64(time), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.bounty_type],
             })  
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().DemandFn('time_expand') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object),  this.txb.pure.bool(minutes_duration),
-                    this.txb.pure.u64(time), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    this.txb.pure.u64(time), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.bounty_type],
             })          
         }

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';
@@ -23,6 +23,8 @@ export  interface Guard_Options {
 
 export class Guard {
     static MAX_INPUT_LENGTH = 10240;
+//    static MAX_PAYLOADS_LENGTH = 4096;
+    
     protected txb;
     protected object : TxbObject;
     get_object() { return this.object }
@@ -96,13 +98,6 @@ export class Guard {
         });
     }
     
-    static signer_guard(txb: TransactionBlock) : GuardAddress {
-        return txb.moveCall({
-            target: Protocol.Instance().GuardFn('signer_guard') as FnCallType,
-            arguments: []
-        }); 
-    }
-    
     static everyone_guard(txb:TransactionBlock) : GuardAddress {
         return txb.moveCall({
             target: Protocol.Instance().GuardFn('everyone_guard') as FnCallType,
@@ -151,7 +146,6 @@ export class Guard {
         [MODULES.entity, 'Entity Resource', 205, [ValueType.TYPE_ADDRESS], ValueType.TYPE_ADDRESS, 'The address of a resource object created by an entity.', ['address']], 
 
         [MODULES.demand, 'Permission', 300, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []],       
-        [MODULES.demand, 'Has Deadline', 301, [], ValueType.TYPE_BOOL, 'Whether to set the expiration time of presenting?', []],
         [MODULES.demand, 'Deadline', 302, [], ValueType.TYPE_U64, 'The expiration time of presenting.', []],   
         [MODULES.demand, 'Bounty Count', 303, [], ValueType.TYPE_U64, 'Number of Bounties.', []],   
         [MODULES.demand, 'Has Guard', 304, [], ValueType.TYPE_BOOL, 'Whether the present guard is set?', []],       
@@ -183,6 +177,8 @@ export class Guard {
         [MODULES.service, 'Required Info', 418, [], ValueType.TYPE_VEC_STRING, 'Names of the required information item that needs to be provided by the customer.', []],  
         [MODULES.service, 'Number of Treasuries', 419, [], ValueType.TYPE_U64, 'The number of treasuries that can be externally withdrawn for purposes such as compensation or incentives.', []],   
         [MODULES.service, 'Contains Treasury', 420, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Does it contain externally withdrawable Treasury for purposes such as compensation or incentives?', ['treasury address']],  
+        [MODULES.service, 'Number of Arbitrations', 421, [], ValueType.TYPE_U64, 'The number of arbitrations that allows a refund to be made from the order at any time based on the arbitration result.', []],   
+        [MODULES.service, 'Contains Arbitration', 422, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Does it contain an arbitration that allows a refund to be made from the order at any time based on the arbitration result.?', ['arbitration address']],  
 
         [MODULES.order, 'Amount', 500, [], ValueType.TYPE_U64, 'Order amount.', []],       
         [MODULES.order, 'Payer', 501, [], ValueType.TYPE_ADDRESS, 'Order payer.', []],
@@ -193,8 +189,8 @@ export class Guard {
         [MODULES.order, 'Discount Used', 506, [], ValueType.TYPE_BOOL, 'Discount coupon used for this order?', []],   
         [MODULES.order, 'Discount', 507, [], ValueType.TYPE_ADDRESS, 'Discount address that already used.', []], 
         [MODULES.order, 'Balance', 508, [], ValueType.TYPE_U64, 'The amount currently in the order.', []], 
-        [MODULES.order, 'Refunded', 509, [], ValueType.TYPE_BOOL, 'Whether a refund has occurred?', []],
-        [MODULES.order, 'Withdrawed', 510, [], ValueType.TYPE_BOOL, 'Whether a service provider withdrawal has occurred?', []],   
+//        [MODULES.order, 'Refunded', 509, [], ValueType.TYPE_BOOL, 'Whether a refund has occurred?', []],
+//        [MODULES.order, 'Withdrawed', 510, [], ValueType.TYPE_BOOL, 'Whether a service provider withdrawal has occurred?', []],   
         [MODULES.order, 'Number of Agents', 511, [], ValueType.TYPE_U64, 'The number of agents for the order.', []], 
         [MODULES.order, 'Has Agent', 512, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address is an order agent?', ['agent address']], 
         [MODULES.order, 'Number of Disputes', 513, [], ValueType.TYPE_U64, 'Number of arbitrations for the order.', []],
@@ -591,7 +587,7 @@ export class 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 +595,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 +640,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 +653,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 +661,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 +717,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/machine.ts

@@ -238,13 +238,6 @@ export class Machine {
             });
         } 
     }
-    
-    destroy() {
-        this.txb.moveCall({
-            target:Protocol.Instance().MachineFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb,  this.object)],
-        })  
-    }
 
     launch() : MachineAddress {
         return this.txb.moveCall({

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/permission.ts

@@ -46,6 +46,7 @@ export enum PermissionIndex {
     //service_change_order_required_pubkey = 224,
     service_pause = 225,
     service_treasury = 226,
+    service_arbitration = 227,
 /*
     reward = 240,
     reward_refund = 241,
@@ -166,7 +167,9 @@ 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.service_treasury, name:'Treasury', description:'Externally withdrawable treasury for compensation or rewards', module: 'service'},
-/*
+    {index:PermissionIndex.service_arbitration, name:'Arbitration', description:'Add/Remove arbitration that allows refunds from orders at any time based on arbitration results', 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'},
@@ -267,12 +270,6 @@ export class  Permission {
         })
     }
 
-    destroy()  {
-        this.txb.moveCall({
-            target:Protocol.Instance().PermissionFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-        })  
-    }
     add_userdefine(index: number, name:string) {
         if (!Permission.IsValidUserDefinedIndex(index)) {
             ERROR(Errors.IsValidUserDefinedIndex, 'add_userdefine');

package/src/progress.ts

@@ -99,14 +99,6 @@ export class Progress {
         })   
     }
 
-    destroy()  {
-        
-        this.txb.moveCall({
-            target:Protocol.Instance().ProgressFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-        })   
-    }
-
     set_namedOperator(name:string, addresses:string[], passport?:PassportObject)  {
         if (!IsValidName(name)) {
             ERROR(Errors.IsValidName, 'name')

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,14 +221,14 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0xfa33358cf5f883038d124855567972241cd7036381fbc150a2208ab0e5939621",
-    wowok_origin:'0xfa33358cf5f883038d124855567972241cd7036381fbc150a2208ab0e5939621' ,
-    base: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
-    base_origin: '0x7efcdab72af2351e5915e34ad2ac8d4ea7f4f408e08138d3498af35a362db782',
-
-    wowok_object: '0x459ed2fd2ad4aac9fd417d50584fae607ee557508dcb9b9f55722e0d18ed81ab',
-    entity_object: '0xfeb95d277598ebb8a358bfda3c62a32d7622de9af7ec3219e67c5749e020f12b',
-    treasury_cap:'0x538cf8f32d59f58c0450a3a97c1eeed3096f4ce63e07e0bdf343a5cc1464887c',
+    wowok: "0x5cfe867c71e4e65bbe3a1214567926a5fef8b4206f7f219bb7446bd9630f528f",
+    wowok_origin:'0x5cfe867c71e4e65bbe3a1214567926a5fef8b4206f7f219bb7446bd9630f528f' ,
+    base: '0xcabc5d750dfacb78550b812531598e02fd83650a0ea804fe48767ecca9e46b51',
+    base_origin: '0xcabc5d750dfacb78550b812531598e02fd83650a0ea804fe48767ecca9e46b51',
+
+    wowok_object: '0xa99cd0ef84bfe5ad9321ef6f2314c529067957fbdff0493f0f59ab7cd68d56e7',
+    entity_object: '0xa3fe3a125aaa73b805b65c1ca04f4936f654eed8edabbb972d0f660b1ca83b95',
+    treasury_cap:'0xfda28fecf646badf857e60d59797709735af2f7af7eec7a1f5c9c65f5f7554d0',
 }
 const MAINNET = {
     wowok: "",

package/src/repository.ts

@@ -82,14 +82,6 @@ export class Repository {
         })    
     }
 
-    destroy()  {
-        if (!Protocol.IsValidObjects([this.object])) return false;
-        this.txb.moveCall({
-            target:Protocol.Instance().RepositoryFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-        })   
-    }
-
     add_data(data:Repository_Policy_Data)  {
         if (!Repository.IsValidName(data.key)) {
             ERROR(Errors.IsValidName)

package/src/service.ts

@@ -4,7 +4,9 @@ import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryOb
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
     TxbObject,
     TreasuryObject,
-    PaymentAddress} from './protocol';
+    PaymentAddress,
+    ArbObject,
+    ArbitrationObject} from './protocol';
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
 import { SuiObjectData } from '@mysten/sui/client';
@@ -67,6 +69,7 @@ export interface WithdrawPayee {
     for_guard?: GuardObject,
 }
 
+
 export type handleDiscountObject = (owner:string, objects:(SuiObjectData|null|undefined)[]) => void;
 export class Service {
     protected pay_token_type;
@@ -128,13 +131,6 @@ export class Service {
             typeArguments:[this.pay_token_type]
         })
     }
-    destroy() {
-        this.txb.moveCall({
-            target:Protocol.Instance().ServiceFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-            typeArguments:[this.pay_token_type]
-        })   
-    }
 
     set_description(description:string, passport?:PassportObject)  {
         if (!IsValidDesription(description)) {
@@ -306,7 +302,7 @@ export class Service {
             })
         }
     }
-    repository_add(repository:RepositoryObject, passport?:PassportObject) {
+    add_repository(repository:RepositoryObject, passport?:PassportObject) {
         if (!Protocol.IsValidObjects([repository])) {
             ERROR(Errors.IsValidObjects, 'repository_add');
         }
@@ -325,7 +321,7 @@ export class Service {
             })  
         }
     }
-    repository_remove(repository_address:string[], removeall?:boolean, passport?:PassportObject) {
+    remove_repository(repository_address:string[], removeall?:boolean, passport?:PassportObject) {
         if (!removeall && repository_address.length===0)  return;
         
         if (!IsValidArray(repository_address, IsValidAddress)) {
@@ -364,7 +360,64 @@ export class Service {
             }
         }
     }
-
+    add_arbitration(arbitraion:ArbitrationObject, passport?:PassportObject) {
+        if (!Protocol.IsValidObjects([arbitraion])) {
+            ERROR(Errors.IsValidObjects, 'arbitration_add');
+        }
+        
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().ServiceFn('arbitration_add_with_passport') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, arbitraion), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ServiceFn('repository_add') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, arbitraion), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })  
+        }
+    }
+    remove_arbitration(address:string[], removeall?:boolean, passport?:PassportObject) {
+        if (!removeall && address.length===0)  return;
+        
+        if (!IsValidArray(address, IsValidAddress)) {
+            ERROR(Errors.IsValidArray,  'arbitration_remove.address');
+        }
+        
+        if (passport) {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ServiceFn('arbitration_remove_all_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ServiceFn('arbitration_remove_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', array_unique(address!)), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })                    
+            }
+        } else {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ServiceFn('arbitration_remove_all') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ServiceFn('arbitration_remove') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', array_unique(address!)), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })                       
+            }
+        }
+    }
     add_withdraw_guards(guards:Service_Guard_Percent[], passport?:PassportObject) {
         if (guards.length === 0) return;
 
@@ -890,20 +943,37 @@ export class Service {
         }    
     }
 
-    refund(order:OrderObject, refund_guard?:string, passport?:PassportObject) {
+    refund_withArb(order:OrderObject, arb:ArbObject, arb_type:string) {
+        if (!Protocol.IsValidObjects([order, arb])) {
+            ERROR(Errors.IsValidObjects, 'refund_withArb.order or arb')
+        }
+        if (!IsValidTokenType(arb_type)) {
+            ERROR(Errors.IsValidTokenType, 'refund_withArb.arb_type')
+        }
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+        this.txb.moveCall({
+            target:Protocol.Instance().ServiceFn('refund_with_arb') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), this.txb.object(arb), this.txb.object(clock)],
+            typeArguments:[this.pay_token_type, arb_type]
+            })     
+    }
+
+    refund(order:OrderObject, refund_guard?:GuardObject, passport?:PassportObject) {
         if (!Protocol.IsValidObjects([order])) {
             ERROR(Errors.IsValidObjects, 'refund.order')
         }
-        if (refund_guard && !IsValidAddress(refund_guard)) {
-            ERROR(Errors.IsValidAddress, 'refund.refund_guard')
+        if (refund_guard && !Protocol.IsValidObjects([refund_guard])) {
+            ERROR(Errors.IsValidObjects, 'refund.refund_guard')
         }
         if (passport && !refund_guard) {
             ERROR(Errors.InvalidParam, 'refund.passport need refund_guard')
         }
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         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), this.txb.object(refund_guard), passport],
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), this.txb.object(refund_guard), 
+                passport, this.txb.object(clock)],
             typeArguments:[this.pay_token_type]
             })               
         } else {
@@ -1104,6 +1174,7 @@ export class Service {
     static MAX_TREASURY_COUNT= 8;
     static MAX_ORDER_AGENT_COUNT = 8;
     static MAX_ORDER_ARBS_COUNT = 8;
+    static MAX_ARBITRATION_COUNT = 8;
 
     static IsValidItemName(name:string) : boolean {
         if (!name) return false;

package/src/treasury.ts

@@ -88,14 +88,6 @@ export class Treasury {
         })
     }
     
-    destroy() {
-        this.txb.moveCall({
-            target:Protocol.Instance().TreasuryFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
-            typeArguments:[this.token_type]
-        }) 
-    }
-    
     set_deposit_guard(guard?:string, passport?:PassportObject)  {
         if (guard && !IsValidAddress(guard)) {
             ERROR(Errors.IsValidAddress, 'set_deposit_guard.guard')