wowok 1.6.66 → 1.6.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.6.66",
+  "version": "1.6.67",
   "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/entity.ts

@@ -1,8 +1,8 @@
 import { Protocol, FnCallType, TxbObject, ResourceAddress, PermissionObject, ResourceObject} from './protocol';
 import { IsValidDesription, IsValidAddress, IsValidName, isValidHttpUrl, Bcs, IsValidArray,  } from './utils';
 import { ERROR, Errors } from './exception';
-import { MarkName, Resource } from './resource';
-import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
+import { GroupName, Resource } from './resource';
+import { Transaction as TransactionBlock, TransactionResult } from '@mysten/sui/transactions';
 
 export interface Safer {
     name: string;
@@ -33,13 +33,15 @@ export class Entity {
         return r
     }
 
-    mark(resource:Resource, address:string, like:MarkName.LikeName | MarkName.DislikeName) {
-        if (!IsValidAddress(address)) ERROR(Errors.IsValidAddress, like);
+    mark(resource:Resource, address:string | TransactionResult, like:GroupName.LikeName | GroupName.DislikeName) {
+        if (typeof(address) === 'string' && !IsValidAddress(address)) {
+            ERROR(Errors.IsValidAddress, like);
+        }
 
         this.txb.moveCall({
             target:Protocol.Instance().entityFn(like) as FnCallType,
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object()), 
-                this.txb.pure.address(address)]
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address]
         })
     }
     /*

package/src/exception.ts

@@ -24,6 +24,7 @@ export enum Errors {
     IsValidUserDefinedIndex = 'invalid user defined permission index',
     bcsTypeInvalid = 'invalid bcs type',
     IsValidServiceItemName = 'invalid service item name',
+    IsValidCoinType = 'not the coin type',
     noPermission = 'no permission',
 }
 

package/src/index.ts

@@ -17,7 +17,7 @@ export * from './arbitration'
 export * from './exception'
 export { BCS, getSuiMoveConfig, } from '@mysten/bcs';
 export { Transaction as TransactionBlock, type TransactionArgument, type TransactionResult} from '@mysten/sui/transactions';
-export { SuiClient, type SuiObjectResponse, type SuiTransactionBlockResponseOptions, type DynamicFieldPage,
+export { SuiClient, type SuiObjectResponse, type SuiTransactionBlockResponseOptions, type DynamicFieldPage, type CoinBalance, type CoinStruct,
     type SuiTransactionBlockResponse as CallResponse} from '@mysten/sui/client';
 export { Ed25519Keypair,  } from '@mysten/sui/keypairs/ed25519';
 export { fromHEX, toHEX } from '@mysten/bcs';

package/src/resource.ts

@@ -13,7 +13,7 @@ export interface ResourceData { // personal folder
     name: string; // folder name
     address: string[]; // objects in folder
 }
-export enum MarkName {
+export enum GroupName {
     LikeName = "like",
     DislikeName = "dislike",
     FavorName = "favor",
@@ -48,6 +48,8 @@ export class Resource {
         });
     }
     add(name:string, object:string[] | TransactionResult[])  {
+        if (object.length === 0) return;
+
         var bString = true;
         if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add.name');
         if (!IsValidArray(object, (item:any) => {
@@ -76,10 +78,11 @@ export class Resource {
         }
     }
 
-    add2(object:TxbObject, name:string[])  {
-        if (typeof(object) === 'string' && !IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
-        if (!IsValidArray(name, IsValidName)) ERROR(Errors.IsValidArray, 'add2');
-        if (!name) return 
+    add2(object:TransactionResult | string, name:string[])  {
+        if (name.length === 0) return;
+
+        if (typeof(object) === 'string' && !IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2.object');
+        if (!IsValidArray(name, IsValidName)) ERROR(Errors.IsValidArray, 'add2.name');
 
         this.txb.moveCall({
             target:Protocol.Instance().resourceFn('add2')  as FnCallType,
@@ -88,34 +91,47 @@ export class Resource {
         });
     }
 
-    remove(name:string, object:string[], removeall?:boolean)  {
-        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
+    remove(name:string, object:string[] | TransactionResult[], removeall?:boolean)  {
         if (object.length===0 && !removeall) return;
+        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
         
+        var bString = true;
+        if (!IsValidArray(object, (item:any) => {
+            if (typeof(item) === 'string') {
+                return IsValidAddress(item)
+            } else {
+                bString = false;
+            }
+            return true;
+        })) {
+            ERROR(Errors.IsValidArray, 'remove.object');
+        }
+
         if (removeall) {
             this.txb.moveCall({
                 target:Protocol.Instance().resourceFn('remove_all')  as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name)]
             });
         } else if(object) {
-            if (!IsValidArray(object, IsValidAddress)) ERROR(Errors.IsValidArray, 'Resource: remove');
-
             this.txb.moveCall({
                 target:Protocol.Instance().resourceFn('remove')  as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
-                    this.txb.pure.vector('address', object)]
+                    bString ? this.txb.pure.vector('address', object as string[]) : this.txb.makeMoveVec({elements:object as TransactionResult[], type:'address'})]
             });
         }
     }
 
-    remove2(object:string, name:string[])  {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove2');
+    remove2(object:TransactionResult | string, name:string[])  {
+        if (typeof(object) === 'string' && !IsValidAddress(object)) {
+            ERROR(Errors.IsValidAddress, 'Resource: remove2');
+        }
         if (!IsValidArray(name, IsValidName)) ERROR(Errors.InvalidParam, 'Resource: remove2');
         if (!name) return
         
         this.txb.moveCall({
             target:Protocol.Instance().resourceFn('remove2')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object), 
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
                 this.txb.pure.vector('string', name)]
         });
     }
@@ -130,29 +146,39 @@ export class Resource {
         }); 
     }
 
-    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');
+    add_tags(object:TransactionResult | string, nick:string, tags:string[]) {
+        if (!nick && tags.length === 0) return;
+        
+        if (typeof(object) === 'string' && !IsValidAddress(object)) {
+            ERROR(Errors.IsValidAddress, 'Resource: add_tags.object');
+        }   
+
+        if (nick && !IsValidName(nick)) ERROR(Errors.IsValidName, 'Resource: add_tags.nick');
+        if (!IsValidArray(tags, IsValidName)) ERROR(Errors.IsValidArray, 'Resource: add_tags.tags');
+        if (tags.length > Resource.MAX_TAGS) {
+            tags = tags.slice(0, Resource.MAX_TAGS)
+        }
 
-        const encode = new TextEncoder();
         this.txb.moveCall({
             target:Protocol.Instance().resourceFn('tags_add')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object), 
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
                 this.txb.pure.string(nick),
                 this.txb.pure.vector('string', tags)
             ]
         });
     }
 
-    remove_tags(object:string) {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'Resource: remove_tags');
+    remove_tags(object:TransactionResult | string) {
+        if (typeof(object) === 'string' && !IsValidAddress(object)) {
+            ERROR(Errors.IsValidAddress, 'Resource: remove_tags');
+        }
         
         this.txb.moveCall({
             target:Protocol.Instance().resourceFn('tags_remove')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object)]
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
+            ]
         });
     }
 }

package/src/utils.ts

@@ -402,6 +402,13 @@ export const IsValidAddress = (addr:string | undefined) : boolean => {
     }
     return true
 }
+export const IsValidCoinType = (coin_type:string | undefined) : boolean => { 
+    if (!coin_type) {
+        return false; 
+    }
+    return coin_type.startsWith('0x2::coin::Coin') || coin_type.startsWith('0x0000000000000000000000000000000000000000000000000000000000000002')
+}
+
 export const IsValidBigint = (value:string | number | undefined | bigint, max:bigint=MAX_U256, min?:bigint) : boolean => {
     if (value === '' || value === undefined) return false;
     try {