wowok 1.2.5 → 1.2.8

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,64 +36,104 @@ 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');
+    launch() {
+        if (!this.object) ERROR(Errors.Fail, 'launch object Invalid');
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.ResourceFn('create')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object)]
+        });
+    }
+    add(name:string, object:string[])  {
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, '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), 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');
+        if (object.length===0 && !removeall) return;
         
         let txb = this.protocol.CurrentSession();
         if (removeall) {
             txb.moveCall({
                 target:this.protocol.ResourceFn('remove_all')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING)]
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(name)]
             });
         } 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), 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');
         
         let txb = this.protocol.CurrentSession();
         txb.moveCall({
             target:this.protocol.ResourceFn('rename')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_name, BCS.STRING), txb.pure(new_name, BCS.STRING)]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_name), txb.pure(new_name)]
         }); 
     }
 
-    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');
+
+        const txb = this.protocol.CurrentSession();
+        const encode = new TextEncoder();
 
-        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),
+                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,7 +1,7 @@
-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';
+import { array_unique, IsValidAddress, IsValidArgType, IsValidArray, IsValidDesription,  IsValidUintLarge, } from './utils';
 import { ERROR, Errors } from './exception';
 import { Resource } from './resource';
 
@@ -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 (!IsValidUintLarge(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 (!IsValidUintLarge(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]
             })
         }
@@ -131,13 +125,11 @@ export class Reward {
     }
 
     add_guard(gurads:RewardGuardPortions[], passport?:PassportObject)  {
-        if (!gurads) {
-            ERROR(Errors.InvalidParam, 'gurads')
-        }
+        if (gurads.length === 0) return;
 
         let bValid = true;
         gurads.forEach((v) => {
-            if (!IsValidUint(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
+            if (!IsValidUintLarge(v.portions) || v.portions > Reward.MAX_PORTIONS_COUNT) bValid = false;
             if (!Protocol.IsValidObjects([v.guard])) bValid = false;
         })
         if (!bValid) {
@@ -168,11 +160,11 @@ export class Reward {
     }
 
     remove_guard(guards:string[], removeall?:boolean, passport?:PassportObject)  {
-        if (!removeall && !guards) {
-            ERROR(Errors.AllInvalid,  'guards & removeall')
+        if (!removeall && guards.length===0) {
+            return
         }
 
-        if (guards && !IsValidArray(guards, IsValidAddress)) {
+        if (!IsValidArray(guards, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'guards')
         }
 
@@ -284,7 +276,8 @@ export class Reward {
         }
         ;
     }
-    deposit(rewards:CoinReward[])  {
+    deposit(rewards:TransactionResult[])  {
+        console.log(rewards)
         if (!rewards || !Protocol.IsValidObjects(rewards)) {
             ERROR(Errors.IsValidArray)
         }
@@ -296,6 +289,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 +314,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 MAX_PORTIONS_COUNT = 255;
+    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 = 600;
+    static MAX_GUARD_COUNT = 16;
 }