wowok 1.5.36 → 1.5.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.5.36",
+  "version": "1.5.38",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -38,7 +38,8 @@
     "move language",
     "move",
     "treasury",
-    "payment"
+    "payment",
+    "arbitration"
   ],
   "author": "wowok",
   "license": "Apache-2.0",

package/src/arbitration.ts

@@ -0,0 +1,448 @@
+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';
+import { ERROR, Errors } from './exception';
+import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
+
+export interface VotingGuard {
+    guard: GuardObject,
+    voting_weight:string, // bigint
+}
+
+export interface Vote {
+    arb: ArbObject,
+    voting_guard?: GuardObject,
+    agrees: number[],
+}
+
+export interface Feedback {
+    arb:ArbObject,
+    feedback:string, 
+    indemnity?:string,  // bigint
+}
+
+export interface Dispute {
+    order: OrderObject,
+    order_token_type: string,
+    description: string,
+    votable_proposition: string[],
+    fee?: CoinObject,
+}
+
+export class Arbitration {
+    protected pay_token_type;
+    protected permission;
+    protected object : TxbObject;
+    protected txb;
+
+    //static token2coin = (token:string) => { return '0x2::coin::Coin<' + token + '>'};
+
+    get_pay_type() {  return this.pay_token_type }
+    get_object() { return this.object }
+    private constructor(txb: TransactionBlock, pay_token_type:string, permission:PermissionObject) {
+        this.pay_token_type = pay_token_type
+        this.txb = txb
+        this.permission = permission
+        this.object = ''
+    }
+    static From(txb: TransactionBlock, token_type:string, permission:PermissionObject, object:TxbObject) : Arbitration {
+        let s = new Arbitration(txb, token_type, permission);
+        s.object = Protocol.TXB_OBJECT(txb, object);
+        return s
+    }
+    static New(txb: TransactionBlock, token_type:string, permission:PermissionObject, description:string, 
+        fee:bigint, passport?:PassportObject) : Arbitration {
+        if (!Protocol.IsValidObjects([permission])) {
+            ERROR(Errors.IsValidObjects)
+        }
+        if (!IsValidTokenType(token_type)) {
+            ERROR(Errors.IsValidTokenType, 'New.token_type') 
+        }
+        if (!IsValidDesription(description)) {
+            ERROR(Errors.IsValidDesription)
+        }
+        if (!IsValidU64(fee)) {
+            ERROR(Errors.IsValidU64, 'New.fee')
+        }
+
+        let pay_token_type = token_type;
+        let obj = new Arbitration(txb, pay_token_type, permission);
+
+        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)],
+                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)],
+                typeArguments:[pay_token_type],
+            })
+        }
+        return obj
+    }
+
+    launch() : ArbitrationAddress  {
+        return this.txb.moveCall({
+            target:Protocol.Instance().ArbitrationFn('create') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)],
+            typeArguments:[this.pay_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().ArbitrationFn('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.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('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.pay_token_type]
+            })
+        }
+    }
+
+    set_fee(fee:bigint, passport?:PassportObject)  {
+        if (!IsValidU64(fee)) {
+            ERROR(Errors.IsValidU64, 'set_fee.fee')
+        }
+        
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('fee_set_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(fee), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('fee_set') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(fee), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }
+    }
+
+    set_endpoint(endpoint?:string, passport?:PassportObject)  {
+        if (endpoint && !IsValidEndpoint(endpoint)) {
+            ERROR(Errors.IsValidEndpoint, 'set_endpoint.endpoint')
+        }
+        
+        if (passport) {
+            if (endpoint) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('endpoint_set_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(endpoint), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('endpoint_none_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 {
+            if (endpoint) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('endpoint_set') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(endpoint), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('endpoint_none') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            }
+        }
+    }
+
+    add_voting_guard(guard: VotingGuard[], passport?:PassportObject) {
+        if (guard.length === 0) return ;
+        if (!IsValidArray(guard, (g:VotingGuard) => Protocol.IsValidObjects([g.guard]) && IsValidU64(g.voting_weight))) {
+            ERROR(Errors.IsValidArray, 'add_voting_guard.guard')
+        }
+        if (passport) {
+            guard.forEach(v => {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('voting_guard_add_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(v.guard), 
+                        this.txb.pure.u64(v.voting_weight), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            })
+        } else {
+            guard.forEach(v => {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('voting_guard_add') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(v.guard), 
+                        this.txb.pure.u64(v.voting_weight), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            })
+        }
+    }
+    remove_voting_guard(guard: string[], removeall?:boolean, passport?:PassportObject) {
+        if (!removeall && guard.length===0)  return;
+        
+        if (!IsValidArray(guard, IsValidAddress)) {
+            ERROR(Errors.IsValidArray,  'remove_voting_guard.guard');
+        }
+
+        if (passport) {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('voting_guard_removeall_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().ArbitrationFn('voting_guard_remove_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', guard), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            }
+        } else {
+            if (removeall) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('voting_guard_removeall') 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().ArbitrationFn('voting_guard_remove') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', guard), 
+                        Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            }
+        }
+    }
+
+    set_guard(apply_guard?:string, passport?:PassportObject) {
+        if (apply_guard && !IsValidAddress(apply_guard)) {
+            ERROR(Errors.IsValidAddress, 'set_guard.apply_guard')
+        }
+        
+        if (passport) {
+            if (apply_guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('usage_guard_set_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(apply_guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('usage_guard_none_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 {
+            if (apply_guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('usage_guard_set') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(apply_guard), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('usage_guard_none') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            }
+        }
+    }
+    pause(pause:boolean, passport?:PassportObject) {
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('pause_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(pause), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('pause') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(pause), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }
+    }
+    vote(param:Vote, passport?:PassportObject) {
+        if (param.voting_guard && !Protocol.IsValidObjects([param.voting_guard])) {
+            ERROR(Errors.IsValidObjects, 'vote.param.voting_guard')
+        }
+        if (!IsValidArray(param.agrees, (v:number)=> IsValidU64(v) && v < Arbitration.MAX_PROPOSITION_COUNT)) {
+            ERROR(Errors.IsValidArray, 'vote.param.agrees')
+        }
+        if (!Protocol.IsValidObjects([param.arb])) {
+            ERROR(Errors.IsValidObjects, 'vote.param.arb')
+        }
+
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+        if (passport) {
+            if (param.voting_guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('vote_with_passport') as FnCallType,
+                    arguments:[passport, this.txb.object(param.voting_guard), Protocol.TXB_OBJECT(this.txb, this.object), 
+                        this.txb.object(param.arb), this.txb.pure.vector('u8', param.agrees),
+                        this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('vote2_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.arb), this.txb.pure.vector('u8', param.agrees),
+                        this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                    typeArguments:[this.pay_token_type]
+                })
+            }
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('vote') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.arb), this.txb.pure.vector('u8', param.agrees),
+                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }
+    }
+
+    arbitration(param:Feedback, passport?:PassportObject) {
+        if (!IsValidDesription(param.feedback)) {
+            ERROR(Errors.IsValidDesription, 'arbitration.param.feedback')
+        }
+        if (!Protocol.IsValidObjects([param.arb])) {
+            ERROR(Errors.IsValidObjects, 'arbitration.param.arb')
+        }
+
+        if (param.indemnity && !IsValidU64(param.indemnity)) {
+            ERROR(Errors.IsValidU64, 'arbitration.param.indemnity')
+        }
+        let ind = this.txb.pure.option('u64', param.indemnity ? param.indemnity : undefined);
+
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('arbitration_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
+                    this.txb.object(param.arb), this.txb.pure.string(param.feedback), ind, Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('arbitration') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                    this.txb.object(param.arb), this.txb.pure.string(param.feedback), ind, Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }
+    }
+
+    withdraw_fee(arb:ArbObject, passport?:PassportObject) {
+        if (!Protocol.IsValidObjects([arb])) {
+            ERROR(Errors.IsValidObjects, 'withdraw_fee.arb')
+        }
+        if (passport) {
+            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), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().ArbitrationFn('withdraw') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                    this.txb.object(arb), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })
+        }
+    }
+
+    dispute(param:Dispute, passport?:PassportObject) {
+        if (!Protocol.IsValidObjects([param.order])) {
+            ERROR(Errors.IsValidObjects, 'dispute.param.order')
+        }
+        if (!IsValidTokenType(param.order_token_type)) {
+            ERROR(Errors.IsValidTokenType, 'dispute.param.order_token_type')
+        }
+        if (!IsValidDesription(param.description)) {
+            ERROR(Errors.IsValidDesription, 'dispute.param.description')
+        }
+        if (!IsValidArray(param.votable_proposition, IsValidName)) {
+            ERROR(Errors.IsValidArray, 'dispute.param.votable_proposition')
+        }
+
+        if (passport) {
+            if (param.fee) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('dispute_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.order), this.txb.pure.string(param.description),
+                        this.txb.pure.vector('string', array_unique(param.votable_proposition)), this.txb.object(param.fee)],
+                    typeArguments:[this.pay_token_type, param.order_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('free_dispute_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.order), this.txb.pure.string(param.description),
+                        this.txb.pure.vector('string', array_unique(param.votable_proposition))],
+                    typeArguments:[this.pay_token_type, param.order_token_type]
+                })
+            }
+        } else {
+            if (param.fee) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('dispute') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.order), this.txb.pure.string(param.description),
+                        this.txb.pure.vector('string', array_unique(param.votable_proposition)), this.txb.object(param.fee)],
+                    typeArguments:[this.pay_token_type, param.order_token_type]
+                })
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().ArbitrationFn('free_dispute') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(param.order), this.txb.pure.string(param.description),
+                        this.txb.pure.vector('string', array_unique(param.votable_proposition))],
+                    typeArguments:[this.pay_token_type, param.order_token_type]
+                })
+            }
+        }
+    }
+
+    change_permission(new_permission:PermissionObject) {
+        if (!Protocol.IsValidObjects([new_permission])) {
+            ERROR(Errors.IsValidObjects)
+        }
+
+        this.txb.moveCall({
+            target:Protocol.Instance().ArbitrationFn('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.pay_token_type]            
+        })    
+        this.permission = new_permission
+    }
+
+    static parseObjectType = (chain_type:string | undefined | null) : string =>  {
+        return parseObjectType(chain_type, 'arbitration::Arbitration<')
+    }
+
+    static parseArbObjectType = (chain_type:string | undefined | null) : string =>  {
+        return parseObjectType(chain_type, 'arb::Arb<')
+    }
+    static MAX_PROPOSITION_COUNT = 16;
+    static MAX_VOTING_GUARD_COUNT = 16;
+}

package/src/guard.ts

@@ -1,7 +1,7 @@
 
 
 import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, TxbObject, GuardObject} from './protocol';
-import { concatenate, array_equal } from './utils';
+import { concatenate, array_equal, ValueTypeConvert } from './utils';
 import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase, insertAtHead } from './utils';
 import { ERROR, Errors } from './exception';
 import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
@@ -195,7 +195,11 @@ export class Guard {
         [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, '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.', []],
+        [MODULES.order, 'Has Arb', 514, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Does the order contain an Arb for arbitration?', ['arb address']],   
+/* @Deprecated
         [MODULES.reward, 'Permission', 600, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []],       
         [MODULES.reward, 'Rewards Remaining', 601, [], ValueType.TYPE_U64, 'Number of rewards to be claimed.', []],
         [MODULES.reward, 'Reward Count Supplied', 602, [], ValueType.TYPE_U64, 'Total rewards supplied.', []],   
@@ -210,9 +214,8 @@ export class Guard {
         [MODULES.reward, 'Portions by A Sponsor', 611, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The portions of sponsorship reward pools for a certain address.', ['address']], 
         [MODULES.reward, 'Number of Sponsors', 612, [], ValueType.TYPE_U64, 'Number of sponsors in the sponsorship reward pool.', []],
         [MODULES.reward, 'Allow Repeated Claims', 613, [], ValueType.TYPE_BOOL, 'Whether to allow repeated claims?', []],  
-    
-        // , means that data fields and data outside the consensus policy definition are allowed to be written
-        // , means that only data fields and data defined by the consensus policy are allowed to be written.
+*/    
+
         [MODULES.machine, 'Permission', 700, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []],
         [MODULES.machine, 'Paused', 701, [], ValueType.TYPE_BOOL, 'Pause the creation of new Progress?', []],
         [MODULES.machine, 'Published', 702, [], ValueType.TYPE_BOOL, 'Is it allowed to create Progress?', []],
@@ -258,7 +261,7 @@ export class Guard {
         [MODULES.wowok, 'Grantor Registration Time', 906, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Registration time of a grantor.', ['address']], 
         [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']], 
-    
+/* @Deprecated
         [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?', []],   
@@ -282,7 +285,7 @@ export class Guard {
         [MODULES.vote, 'Top1 Option by Votes', 1121, [], ValueType.TYPE_STRING, 'The content 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.vote, 'Voted Time by Address', 1113, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The time of whether an address has been voted on.', ['adddress']], 
- 
+*/ 
         [MODULES.payment, 'Sender', 1200, [], ValueType.TYPE_ADDRESS, 'Payment originator address.', []], 
         [MODULES.payment, 'Total Amount', 1201, [], ValueType.TYPE_U128, "Payment amount.", []], 
         [MODULES.payment, 'Remark', 1202, [], ValueType.TYPE_STRING, 'Payment remark.', ['address']], 
@@ -298,22 +301,6 @@ export class Guard {
         [MODULES.payment, 'Treasury Address', 1212, [], ValueType.TYPE_ADDRESS, 'The Treasury from which the payment comes.', []], 
         [MODULES.payment, 'Biz-ID', 1213, [], ValueType.TYPE_U64, 'Bisiness ID number of the payment.', []], 
 
-        [MODULES.reward, 'Amount', 1300, [], ValueType.TYPE_U64, 'Total amount deposited with reward.' , []], 
-        [MODULES.reward, 'Original Type Deposited', 1301, [], ValueType.TYPE_STRING, "Original type name of asserts deposited.", []], 
-        [MODULES.reward, 'Original Package', 1302, [], ValueType.TYPE_ADDRESS, 'Original package address of asserts deposited.', []], 
-        [MODULES.reward, 'Original Module', 1303, [], ValueType.TYPE_STRING, 'Original module name of asserts deposited.', []], 
-        [MODULES.reward, 'Type Deposited', 1304, [], ValueType.TYPE_STRING, 'Type name of asserts deposited.', []], 
-        [MODULES.reward, 'Package', 1305, [], ValueType.TYPE_ADDRESS, 'Package address of asserts deposited.', , []], 
-        [MODULES.reward, 'Module', 1306, [], ValueType.TYPE_STRING, 'Module name of asserts deposited.', []], 
-        [MODULES.reward, 'Balance', 1307, [], ValueType.TYPE_U64, 'The amount currently remaining in reward.', []], 
-        [MODULES.reward, 'Deposit Time', 1308, [], ValueType.TYPE_U64, 'Deposit time.', []], 
-        [MODULES.reward, 'Be Withdrawable', 1309, [], ValueType.TYPE_BOOL, 'Whether to allow amount withdrawal?' , []], 
-        [MODULES.reward, 'Be Deposited from', 1310, [], ValueType.TYPE_BOOL, 'Is the deposit from source set?', []], 
-        [MODULES.reward, 'Deposited from Object', 1311, [], ValueType.TYPE_ADDRESS, 'The source object set when depositing.', []], 
-        [MODULES.reward, 'Contains Guard', 1312, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether the guard for withdrawal is set up?', []], 
-        [MODULES.reward, 'Withdrawal percentage', 1313, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U8, 'The percentage of withdrawals corresponding to Guard.', ['address']], 
-        [MODULES.reward, 'Number of withdrawals', 1314, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'Number of withdrawals.'], 
-
         [MODULES.treasury, 'Permission', 1400, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []], 
         [MODULES.treasury, 'Balance', 1401, [], ValueType.TYPE_U64, "Treasury balance.", []], 
         [MODULES.treasury, 'Number of Flow Records', 1402, [], ValueType.TYPE_U64, 'Number of treasury transactions.', []], 
@@ -344,12 +331,12 @@ export class Guard {
         [MODULES.treasury, 'Operation at Least Times by a Signer', 1427, [ValueType.TYPE_U8, ValueType.TYPE_ADDRESS, ValueType.TYPE_U8], ValueType.TYPE_BOOL, 'Does it operate at least a certain number of times by a signer?', ['operation', 'signer address', 'at least times']], 
     
         [MODULES.arbitration, 'Permission', 1500, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []], 
-        [MODULES.arbitration, 'Published', 1501, [], ValueType.TYPE_BOOL, "Is it allowed to create Arb?", []], 
+        [MODULES.arbitration, 'Paused', 1501, [], ValueType.TYPE_BOOL, "Is it allowed to create Arb?", []], 
         [MODULES.arbitration, 'Fee', 1502, [], ValueType.TYPE_U64, 'Cost of arbitration.', []], 
         [MODULES.arbitration, 'Has Endpoint', 1503, [], ValueType.TYPE_BOOL, 'Is the endpoint set?', []], 
         [MODULES.arbitration, 'Endpoint', 1504, [], ValueType.TYPE_STRING, 'Endpoint url/ipfs.', []], 
-        [MODULES.arbitration, 'Has Guard', 1505, [], ValueType.TYPE_BOOL, 'Is there Guard set to apply for arbitration?', []], 
-        [MODULES.arbitration, 'Guard', 1506, [], ValueType.TYPE_ADDRESS, 'Guard to apply for arbitration.', []], 
+        [MODULES.arbitration, 'Has Customer Guard', 1505, [], ValueType.TYPE_BOOL, 'Is there Guard set to apply for arbitration?', []], 
+        [MODULES.arbitration, 'Customer Guard', 1506, [], ValueType.TYPE_ADDRESS, 'Guard to apply for arbitration.', []], 
         [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']], 

package/src/index.ts

@@ -4,15 +4,15 @@ export * from './utils'
 export * from './permission'
 export * from './guard'
 export * from './repository'
-export * from './vote'
 export * from './protocol'
 export * from './passport'
 export * from './machine'
 export * from './service'
-export * from './graphql'
 export * from './entity'
 export * from './wowok'
 export * from './resource'
 export * from './treasury'
 export * from './payment'
-export * from './reward'
+export * from './arbitration'
+// export * from './reward'
+// export * from './vote'