wowok 1.2.4 → 1.2.7

package/src/repository.ts

@@ -1,7 +1,7 @@
 import { BCS } from '@mysten/bcs';
-import { Protocol, FnCallType, ValueType, RepositoryObject, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
+import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
 import { PermissionIndexType, Permission } from './permission'
-import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone,  } from './utils';
+import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone, IsValidName,  } from './utils';
 import { ERROR, Errors } from './exception';
 import { Resource } from './resource';
 
@@ -9,10 +9,12 @@ export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
     POLICY_MODE_STRICT = 1,
 }
+
+
 export type Repository_Policy = {
     key:string;
     description: string;
-    value_type: ValueType;
+    data_type: RepositoryValueType;
     permission?: PermissionIndexType; // PermissionIndex like, must be geater than 10000
 }
 export type Repository_Policy_Data = {
@@ -142,13 +144,13 @@ export class Repository {
     }
     add_reference(references:string[], passport?:PassportObject) {
         if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
+            ERROR(Errors.InvalidParam, 'add_reference')
         }
 
         if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+            ERROR(Errors.IsValidArray, 'add_reference')
         }
-
+        console.log(array_unique(references))
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
@@ -167,12 +169,12 @@ export class Repository {
         }
     }
     remove_reference(references:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
+        if (!references && !removeall) {
+            ERROR(Errors.InvalidParam, 'remove_reference')
         }
 
-        if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+        if (references && !IsValidArray(references, IsValidAddress)) {
+            ERROR(Errors.IsValidArray, 'remove_reference')
         }
 
         let txb = this.protocol.CurrentSession();
@@ -233,7 +235,7 @@ export class Repository {
                     arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
                         txb.pure(policy.key), 
                         txb.pure(policy.description),
-                        permission_index, txb.pure(policy.value_type, BCS.U8),
+                        permission_index, txb.pure(policy.data_type, BCS.U8),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 })              
             } else {
@@ -242,15 +244,15 @@ export class Repository {
                     arguments:[Protocol.TXB_OBJECT(txb, this.object), 
                         txb.pure(policy.key), 
                         txb.pure(policy.description),
-                        permission_index, txb.pure(policy.value_type, BCS.U8),
+                        permission_index, txb.pure(policy.data_type, BCS.U8),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 })  
             }
         });    
     }
 
-    remove_policies(policy_keys:string[], removeall?:boolean, passport?:PassportObject)  {
-        if (!removeall && !policy_keys) {
+    remove_policies(policy_keys:string[], passport?:PassportObject)  {
+        if (!policy_keys) {
             ERROR(Errors.AllInvalid, 'policy_keys & removeall')
         }
         if (policy_keys && !IsValidArray(policy_keys, Repository.IsValidName)){
@@ -259,36 +261,44 @@ export class Repository {
 
         let txb = this.protocol.CurrentSession();
         if (passport) {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_all_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)]
-                })          
-            } else {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
-                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)]
-                })                
-            }
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_remove_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })                
         } else {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_all') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)]
-                })          
-            } else {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), 
-                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)]
-                })                
-            }
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_remove') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })                     
         }
-        
     }
+    rename_policy(policy_key:string, new_policy_key:string, passport?:PassportObject) {
+        if (!IsValidName(policy_key) || !IsValidName(new_policy_key)) {
+            ERROR(Errors.IsValidName, 'change_policy')
+        }
+
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_rename_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(policy_key, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })     
+        } else {
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_rename') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(policy_key, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })       
+        }
+    }
+
     // PermissionIndex.description_set
     set_description(description:string, passport?:PassportObject)  {
         if (!IsValidDesription(description)){
@@ -347,7 +357,6 @@ export class Repository {
                     Protocol.TXB_OBJECT(txb, this.permission)]
             })   
         } 
-        
     }
 
     set_policy_permission(policy:string, permission_index?:number, passport?:PassportObject)  {
@@ -376,7 +385,6 @@ export class Repository {
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), index, Protocol.TXB_OBJECT(txb, this.permission)]
             })   
         }     
-        
     }
 
     change_permission(new_permission:PermissionObject) {
@@ -392,14 +400,26 @@ export class Repository {
         this.permission = new_permission  
     }
 
-    static MAX_POLICY_COUNT = 1000;
+    static MAX_POLICY_COUNT = 200;
     static MAX_KEY_LENGTH = 128;
     static MAX_VALUE_LENGTH = 204800;
+    static MAX_REFERENCE_COUNT = 100;
     static IsValidName = (key:string)  => {
         return key.length <= Repository.MAX_KEY_LENGTH && key.length != 0;
     }
     static IsValidValue = (value:Uint8Array)  => {
         return value.length < Repository.MAX_VALUE_LENGTH;
     }
+    static parseObjectType = (chain_type:string) : string =>  {
+        if (chain_type) {
+            const s = 'repository::Repository<'
+            const i = chain_type.indexOf(s);
+            if (i > 0) {
+                let r = chain_type.slice(i + s.length, chain_type.length-1);
+                return r
+            }
+        }
+        return '';
+    }
 }
 

package/src/resource.ts

@@ -1,14 +1,25 @@
 import { BCS } from '@mysten/bcs';
 import { Protocol, FnCallType, TxbObject, ResourceAddress} from './protocol';
-import { IsValidDesription, IsValidAddress, IsValidName,  } from './utils';
+import { IsValidDesription, IsValidAddress, IsValidName, IsValidArray,  } from './utils';
 import { ERROR, Errors } from './exception';
+export interface Tags {
+    address: string;
+    nick: string;
+    tags: string[];
+}
 
+export interface ResourceData {
+    name: string;
+    address: string[];
+}
 
 export class Resource {
-    static MAX_WORDS_LEN = 102400;
-    static IsValidWords(words:string) : boolean {
-        return words.length <= Resource.MAX_WORDS_LEN
-    }
+    static MAX_ADDRESS_COUNT = 600;
+    static MAX_TAGS = 8;
+
+    static LikeName = "like";
+    static DislikeName = "dislike";
+    static FavorName = "favor";
 
     protected object:TxbObject;
     protected protocol;
@@ -25,18 +36,31 @@ export class Resource {
         return r
     }
 
-    add(name:string, object:string)  {
-        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: add');
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: add');
+    add(name:string, object:string[])  {
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add');
+        if (!object) ERROR(Errors.InvalidParam, 'add')
+        if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'add');
 
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
             target:this.protocol.ResourceFn('add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, BCS.ADDRESS)]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, 'vector<address>')]
+        });
+    }
+
+    add2(object:string, name:string[])  {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
+        if (!IsValidArray(name, IsValidName)) ERROR(Errors.IsValidArray, 'add2');
+        if (!name) return 
+
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('add2')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(name, 'vector<string>')]
         });
     }
 
-    remove(name:string, object?:string, removeall?:boolean)  {
+    remove(name:string, object?:string[], removeall?:boolean)  {
         if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
         if (!object && !removeall) ERROR(Errors.InvalidParam, 'Resource: remove, BOTH param undefined');
         
@@ -47,15 +71,27 @@ export class Resource {
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING)]
             });
         } else if(object) {
-            if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove');
+            if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'Resource: remove');
 
             txb.moveCall({
                 target:this.protocol.ResourceFn('remove')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, BCS.ADDRESS)]
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), txb.pure(object, 'vector<address>')]
             });
         }
     }
 
+    remove2(object:string, name:string[])  {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove2');
+        if (!IsValidArray(name, IsValidName)) ERROR(Errors.InvalidParam, 'Resource: remove2');
+        if (!name) return
+        
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('remove2')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(name, 'vector<string>')]
+        });
+    }
+
     rename(old_name:string, new_name:string)  {
         if (!IsValidName(new_name)) ERROR(Errors.IsValidName, 'Resource: rename');
         
@@ -66,23 +102,28 @@ export class Resource {
         }); 
     }
 
-    add_words(object:string, words:string) {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: add_words');
-        if (!Resource.IsValidWords(words)) ERROR(Errors.Fail, 'Resource: add_words');
+    add_tags(object:string, nick:string, tags:string[]) {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add_tags');
+        if (!nick || !tags) return;
+        if (!IsValidName(nick)) ERROR(Errors.IsValidName, 'add_tags');
+        if (!IsValidArray(tags, IsValidName)) ERROR(Errors.IsValidArray, 'add_tags');
+        if (tags.length > Resource.MAX_TAGS) ERROR(Errors.InvalidParam, 'add_tags');
 
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target:this.protocol.ResourceFn('words_add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(words, BCS.STRING)]
+            target:this.protocol.ResourceFn('tags_add')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS), txb.pure(nick, BCS.STRING),
+                txb.pure(tags, 'vector<string>')
+            ]
         });
     }
 
-    remove_words(object:string) {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove_words');
+    remove_tags(object:string) {
+        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove_tags');
 
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target:this.protocol.ResourceFn('words_remove')  as FnCallType,
+            target:this.protocol.ResourceFn('tags_remove')  as FnCallType,
             arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(object, BCS.ADDRESS)]
         });
     }

package/src/reward.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, type TransactionResult } from '@mysten/sui.js/transactions';
+import { TransactionArgument, TransactionBlock, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS} from '@mysten/bcs';
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RewardAddress, Protocol, TxbObject, } from './protocol';
 import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription,  IsValidUint, } from './utils';
@@ -31,7 +31,7 @@ export class Reward {
         return  r
     }
     static New(protocol:Protocol, earnest_type:string, permission:PermissionObject, description:string, 
-        minutes_duration:number, passport?:PassportObject) : Reward {
+        ms_expand:boolean, time:number, passport?:PassportObject) : Reward {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects, 'permission')
         }
@@ -41,8 +41,8 @@ export class Reward {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        if (!IsValidUint(minutes_duration)) {
-            ERROR(Errors.IsValidUint, 'minutes_duration')
+        if (!IsValidUint(time)) {
+            ERROR(Errors.IsValidUint, 'time')
         }
 
         let r = new Reward(protocol, earnest_type,  permission);
@@ -51,14 +51,14 @@ export class Reward {
         if (passport) {
             r.object = txb.moveCall({
                 target:protocol.RewardFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure(description), txb.pure(minutes_duration, BCS.U64), 
-                    txb.object(Protocol.CLOCK_OBJECT), Protocol.TXB_OBJECT(txb, permission)], 
+                arguments:[passport, txb.pure(description), txb.pure(ms_expand, BCS.BOOL), txb.pure(time, BCS.U64), 
+                    txb.object(Protocol.CLOCK_OBJECT), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[earnest_type]
             })
         } else {
             r.object = txb.moveCall({
                 target:protocol.RewardFn('new') as FnCallType,
-                arguments:[txb.pure(description), txb.pure(minutes_duration, BCS.U64), 
+                arguments:[txb.pure(description), txb.pure(ms_expand, BCS.BOOL), txb.pure(time, BCS.U64), 
                     txb.object(Protocol.CLOCK_OBJECT), Protocol.TXB_OBJECT(txb, permission)], 
                 typeArguments:[earnest_type]
             })
@@ -82,15 +82,7 @@ export class Reward {
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
         })   
     }
-/*
-    mark(like:'like' | 'unlike', resource:Resource)  {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.RewardFn(like) as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(txb, resource.get_object()), Protocol.TXB_OBJECT(txb, this.object)],
-        })   
-    }
-*/
+
     refund(passport?:PassportObject) {
         let txb = this.protocol.CurrentSession();
         if (passport) {
@@ -108,8 +100,8 @@ export class Reward {
         }
     }
 
-    expand_time(minutes_expand:number, passport?:PassportObject)  {
-        if (!IsValidUint(minutes_expand)) {
+    expand_time(ms_expand:boolean, time:number, passport?:PassportObject)  {
+        if (!IsValidUint(time)) {
             ERROR(Errors.IsValidUint, 'minutes_expand')
         }
 
@@ -117,13 +109,15 @@ export class Reward {
         if (passport) {
             txb.moveCall({
                 target:this.protocol.RewardFn('time_expand_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_expand, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)], 
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(ms_expand, BCS.BOOL),
+                    txb.pure(time, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)], 
                 typeArguments:[this.earnest_type]
             })
         } else {
             txb.moveCall({
                 target:this.protocol.RewardFn('time_expand') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_expand, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)], 
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(ms_expand, BCS.BOOL),
+                    txb.pure(time, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)], 
                 typeArguments:[this.earnest_type]
             })
         }
@@ -284,7 +278,8 @@ export class Reward {
         }
         ;
     }
-    deposit(rewards:CoinReward[])  {
+    deposit(rewards:TransactionResult[])  {
+        console.log(rewards)
         if (!rewards || !Protocol.IsValidObjects(rewards)) {
             ERROR(Errors.IsValidArray)
         }
@@ -296,6 +291,23 @@ export class Reward {
             typeArguments:[this.earnest_type]
         })
     }
+    allow_claim(bAllowClaim: boolean, passport?:PassportObject) {
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target:this.protocol.RewardFn('allow_claim_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission),
+                    txb.pure(bAllowClaim, BCS.BOOL)], 
+                typeArguments:[this.earnest_type]
+            })      
+        } else {
+            txb.moveCall({
+                target:this.protocol.RewardFn('allow_claim') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission), txb.pure(bAllowClaim, BCS.BOOL)], 
+                typeArguments:[this.earnest_type]
+            })            
+        }
+    }
 
     change_permission(new_permission:PermissionObject) {
         if (!Protocol.IsValidObjects([new_permission])) {
@@ -304,12 +316,23 @@ export class Reward {
 
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target:this.protocol.RewardFn('this.permission_set') as FnCallType,
+            target:this.protocol.RewardFn('permission_set') as FnCallType,
             arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission), Protocol.TXB_OBJECT(txb, new_permission)],
             typeArguments:[this.earnest_type]            
         })    
         this.permission = new_permission
     }
-
+    static parseObjectType = (chain_type:string) : string =>  {
+        if (chain_type) {
+            const s = 'reward::Reward<'
+            const i = chain_type.indexOf(s);
+            if (i > 0) {
+                let r = chain_type.slice(i + s.length, chain_type.length-1);
+                return r
+            }
+        }
+        return '';
+    }
     static MAX_PORTIONS_COUNT = 255;
+    static MAX_GUARD_COUNT = 16;
 }