wowok 1.6.66 → 1.6.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.6.66",
+  "version": "1.6.69",
   "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,13 +1,10 @@
 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 { TagName, Resource } from './resource';
+import { Transaction as TransactionBlock, TransactionResult } from '@mysten/sui/transactions';
+
 
-export interface Safer {
-    name: string;
-    value: string;
-}
 export interface Entity_Info {
     name: string;
     description?: string;
@@ -33,51 +30,18 @@ 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:TagName.Like | TagName.Dislike) {
+        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)]
-        })
-    }
-    /*
-    add_safer(safer: Safer[], bExistModify:boolean=true) {
-        if (safer.length === 0) return ;
-        if (!IsValidArray(safer, (v:Safer) => {
-            if (!IsValidName(v.name) || !IsValidDesription(v.value)) {
-                return false
-            }
-        })) {
-            ERROR(Errors.InvalidParam, 'add_safer');
-        }
-
-        const name = safer.map((v)=>v.name);
-        const value = safer.map((v)=>v.value);
-        this.txb.moveCall({
-            target:Protocol.Instance().entityFn('safer_add') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name), 
-                this.txb.pure.vector('string', value),  this.txb.pure.bool(bExistModify)]
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address]
         })
     }
 
-    remove_safer(name:string[], removeall?:boolean) {
-        if (name.length === 0 && !removeall) return;
-
-        if (removeall) {
-            this.txb.moveCall({
-                target:Protocol.Instance().entityFn('safer_remove_all') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
-            })
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().entityFn('safer_remove') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name)]
-            })
-        }
-    }*/
-
     update(info: Entity_Info) {
         if (info?.name && !IsValidName(info.name)) ERROR(Errors.IsValidName, 'update');
         if (info?.description && !IsValidDesription(info.description)) ERROR(Errors.IsValidDesription, 'update');
@@ -114,14 +78,21 @@ export class Entity {
         }) 
     }
     
-    destroy_resource(resource:Resource) {
+    destroy_resource(resource:Resource) { // Resource must self-owned.
         return this.txb.moveCall({
             target:Protocol.Instance().entityFn('resource_destroy') as FnCallType,
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object())]
         })
     }
 
-    transfer_resource(resource:Resource, new_address:string) {
+    use_resource(resource:Resource) { // Resource must self-owned.
+        return this.txb.moveCall({
+            target:Protocol.Instance().entityFn('resource_use') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object())]
+        })
+    }
+
+    transfer_resource(resource:Resource, new_address:string) { // Resource must self-owned.
         if (!IsValidAddress(new_address)) ERROR(Errors.IsValidAddress, 'transfer_resource');
         
         return this.txb.moveCall({

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

@@ -64,6 +64,7 @@ export type PaymentAddress = TransactionResult;
 export type ReceivedObject = TransactionResult | string | TransactionArgument;
 export type CoinWrapperObject = TransactionResult;
 
+export type TxbAddress = string | TransactionResult;
 export type TxbObject = string | TransactionResult | TransactionArgument | GuardObject |  RepositoryObject | PermissionObject | MachineObject | PassportObject |
     DemandObject | ServiceObject  | OrderObject | DiscountObject  | DemandObject | ResourceObject | EntityObject | ArbitrationObject | ArbObject | TreasuryObject;
 
@@ -219,15 +220,15 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x30ed8dfa0b8597b1c753b8345e3c7b8792041feeaa7dc765bacd10f63c4402b7",
-    wowok_origin:'0x30ed8dfa0b8597b1c753b8345e3c7b8792041feeaa7dc765bacd10f63c4402b7' ,
-    base: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
-    base_origin: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
-
-    wowok_object: '0xc26fcc691dbd4c05d753e170a11c151dbdec130b77691b391d1012dfb8c445bf',
-    entity_object: '0x1de2c69c9a795f56a8c409b54bbf50e544d4178d7c64b5520d929f5eea65b5ff',
-    treasury_cap:'0x9f415c863f0c26103e70fc4a739fea479ff20544057a3c5665db16c0b8650f7c',
-    oracle_object:'0x6c7d9b8ab0e9d21291e0128ca3e0d550b30f375f1e008381f2fbeef6753e6dcf',
+    wowok: "0xe98ef6b139de57b59d71496dc2b48d4e36e195013194748bdfe90688a9821132",
+    wowok_origin:'0xe98ef6b139de57b59d71496dc2b48d4e36e195013194748bdfe90688a9821132' ,
+    base: '0xa475682a229bcf913b2d561370ed44a055d0091a4a02b25d780d48aed03df267',
+    base_origin: '0xa475682a229bcf913b2d561370ed44a055d0091a4a02b25d780d48aed03df267',
+
+    wowok_object: '0xf2d3dc8667e21ca03fd808e51f7f9f291bad861bab1f62b4f07f39834830a5d9',
+    entity_object: '0x40eb7a354875548a55a196c0f1cbbf217026fee9d86f94615b992878a6629e03',
+    treasury_cap:'0x405105d71add6c57c1de0dbceb2676320ddb5bbe4c3cfdf79c7b23783e9e3761',
+    oracle_object:'0x4592d870a3c79c37d49fe55d1eba3ed2e82bcf707822d698beeceacce0dabdc6',
 }
 const MAINNET = {
     wowok: "",

package/src/repository.ts

@@ -460,9 +460,6 @@ export class Repository {
     static IsValidValue = (value:Uint8Array)  => {
         return value.length < Repository.MAX_VALUE_LENGTH;
     }
-    static parseObjectType = (chain_type?:string | null) : string =>  {
-        return parseObjectType(chain_type, 'repository::Repository<');
-    }
 
     static rpc_de_data(fields:any) : RepData [] {
         const rep: RepData[] = fields?.map((v:any) => {

package/src/resource.ts

@@ -1,29 +1,32 @@
-import { Protocol, FnCallType, TxbObject, ResourceAddress} from './protocol';
+import { Protocol, FnCallType, TxbObject, TxbAddress} from './protocol';
 import { IsValidDesription, IsValidAddress, IsValidName, IsValidArray,  } from './utils';
 import { ERROR, Errors } from './exception';
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
+import { Entity } from './entity';
 
 export interface Tags { // tag am address
     address: string; // address to tag
-    nick: string; //  named address
+    name?: string; //  named address
     tags: string[]; // tags for address
 }
 
-export interface ResourceData { // personal folder
-    name: string; // folder name
+export interface TagData { 
+    tag: string; // tag name
     address: string[]; // objects in folder
-}
-export enum MarkName {
-    LikeName = "like",
-    DislikeName = "dislike",
-    FavorName = "favor",
-    LaunchName = 'launch',
-    OrderName = 'order',
+} 
+export enum TagName {
+    Like = "like",
+    Dislike = "dislike",
+    Launch = 'launch',
+    Order = 'order',
+    Payment = 'payment'
 }
 
 export class Resource {
-    static MAX_ADDRESS_COUNT = 600;
-    static MAX_TAGS = 8;
+    static MAX_ADDRESS_COUNT_FOR_TAG = 1000; // max address count
+    static MAX_TAG_COUNT_FOR_ADDRESS = 64; // max tag count for an address
+    //static MAX_ADDRESS_COUNT_FOR_MARK = 200; // max address count for a mark
+    //static MAX_MARK_COUNT = 600; // max mark count
 
     protected object:TxbObject;
     protected txb;
@@ -40,120 +43,124 @@ export class Resource {
         return r
     }
 
-    launch() {
+    launch() : TxbAddress{
         if (!this.object) ERROR(Errors.Fail, 'launch object Invalid');
-        this.txb.moveCall({
+        return this.txb.moveCall({
             target:Protocol.Instance().resourceFn('create')  as FnCallType,
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
         });
     }
-    add(name:string, object:string[] | TransactionResult[])  {
-        var bString = true;
-        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'add.name');
-        if (!IsValidArray(object, (item:any) => {
-            if (typeof(item) === 'string') {
-                return IsValidAddress(item)
-            } else {
-                bString = false;
-            }
-            return true;
-        })) {
-            ERROR(Errors.IsValidArray, 'add.object');
-        }
 
-        if (bString) {
-            this.txb.moveCall({
-                target:Protocol.Instance().resourceFn('add')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
-                    this.txb.pure.vector('address', object as string[])]
-            });            
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().resourceFn('add')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(name), 
-                    this.txb.makeMoveVec({elements:object as TransactionResult[], type:'address'})]
-            });   
+    private resolve_add(address:TransactionResult | string, tags:string[]) {
+        if (tags.find(v => v===TagName.Like)) {
+            Entity.From(this.txb).mark(this, address, TagName.Like);
         }
+        if (tags.find(v => v===TagName.Dislike)) {
+            Entity.From(this.txb).mark(this, address, TagName.Dislike);
+        }  
+        return (tags.filter(v => v !== TagName.Like && v !== TagName.Dislike && IsValidName(v)));
     }
 
-    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 
+    add(address:TransactionResult | string, tags:string[], name?:string) { 
+        if (typeof(address) === 'string' && !IsValidAddress(address)) {
+            ERROR(Errors.IsValidAddress, 'Resource: add.address');
+        }   
+
+        var realtags = this.resolve_add(address, tags);
+        if (!name && realtags.length === 0) return;
+
+        if (name && !IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: add.name');
+        if (realtags.length > Resource.MAX_TAG_COUNT_FOR_ADDRESS) {
+            realtags = realtags.slice(0, Resource.MAX_TAG_COUNT_FOR_ADDRESS)
+        }
 
         this.txb.moveCall({
-            target:Protocol.Instance().resourceFn('add2')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
-                this.txb.pure.vector('string', name)]
+            target:Protocol.Instance().resourceFn('add')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address, 
+                this.txb.pure.option('string', name),
+                this.txb.pure.vector('string', realtags)
+            ]
         });
     }
 
-    remove(name:string, object:string[], removeall?:boolean)  {
-        if (!IsValidName(name)) ERROR(Errors.IsValidName, 'Resource: remove');
-        if (object.length===0 && !removeall) return;
-        
-        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)]
-            });
+    remove(address:TransactionResult | string, tags:string[]) { 
+        if (typeof(address) === 'string' && !IsValidAddress(address)) {
+            ERROR(Errors.IsValidAddress, 'Resource: remove.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
         
         this.txb.moveCall({
-            target:Protocol.Instance().resourceFn('remove2')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object), 
-                this.txb.pure.vector('string', name)]
+            target:Protocol.Instance().resourceFn('remove')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address, 
+                this.txb.pure.vector('string', tags)
+            ]
         });
     }
 
-    rename(old_name:string, new_name:string)  {
-        if (!IsValidName(new_name)) ERROR(Errors.IsValidName, 'Resource: rename');
+    removeall(address: TxbAddress) {
+        if (typeof(address) === 'string' && !IsValidAddress(address)) {
+            ERROR(Errors.IsValidAddress, 'Resource: removeall.address');
+        }
         
         this.txb.moveCall({
-            target:Protocol.Instance().resourceFn('rename')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(old_name), 
-                this.txb.pure.string(new_name)]
-        }); 
+            target:Protocol.Instance().resourceFn('removeall')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address, 
+            ]
+        });
     }
 
-    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');
+    query(address: TxbAddress) {
+        if (typeof(address) === 'string' && !IsValidAddress(address)) {
+            ERROR(Errors.IsValidAddress, 'Resource: query.address');
+        } 
 
-        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), 
-                this.txb.pure.string(nick),
-                this.txb.pure.vector('string', tags)
+            target:Protocol.Instance().resourceFn('query')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
+                typeof(address) === 'string' ? this.txb.pure.address(address) : address, 
             ]
-        });
+        })
     }
 
-    remove_tags(object:string) {
-        if (!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)]
-        });
+    static TagData(tags: Tags[], innerTag:boolean=true) : TagData[] {
+        const data : TagData[] = [];
+        tags.forEach(v => {
+          v.tags.forEach(i => {
+            const f = data.find(k => k.tag === i);
+            if (f) {
+              if (!f.address.find(k => k === v.address)) { // add address
+                f.address.push(v.address)
+              } 
+            } else {
+                data.push({tag:i, address:[v.address]}); // add tag
+            }
+          })
+        })
+        if (innerTag) {
+            (Object.keys(TagName) as Array<keyof typeof TagName>).forEach(i => {
+                if (!data.find(v => v.tag === TagName[i])) {
+                    data.push({tag:TagName[i], address:[]})
+                }                
+            })
+        }
+        return data;
+    }
+
+    static Tags(data: TagData) : Tags[] {
+        const tags : Tags[] = [];
+        data.address.forEach(v => {
+            const f = tags.find(i => i.address === v);
+            if (f) {
+                if (!f.tags.find(k => k === data.tag)) {
+                    f.tags.push(data.tag)
+                }
+            } else {
+                tags.push({address:v, tags:[data.tag]})
+            }
+        })
+        return tags;
     }
 }
 

package/src/treasury.ts

@@ -415,7 +415,7 @@ export class Treasury {
         })    
         this.permission = new_permission
     }
-    static parseObjectType = (chain_type:string) : string =>  {
+    static parseObjectType = (chain_type?:string) : string =>  {
         return parseObjectType(chain_type, 'treasury::Treasury<')
     }
     

package/src/utils.ts

@@ -177,6 +177,10 @@ export class Bcs {
             "safer_value": "vector<string>",
             'like': BCS.U32,
             'dislike': BCS.U32,
+        });
+        this.bcs.registerStructType('TagStruct', {
+            'nick': 'string',
+            'tags': "vector<string>",
         })
         this.bcs.registerStructType('PersonalInfo', {
             'name': 'vector<u8>',
@@ -335,7 +339,12 @@ export class Bcs {
         r.name = new TextDecoder().decode(Uint8Array.from(r.name));
         r.description = new TextDecoder().decode(Uint8Array.from(r.description));
         return r
-    }        
+    }    
+    de_tags(data:Uint8Array | undefined) : any {
+        if (!data || data.length === 0) return ''
+        const struct_vec = this.bcs.de('vector<u8>', data);
+        return this.bcs.de('TagStruct', Uint8Array.from(struct_vec));
+    }   
     de_perms(data:Uint8Array | undefined) : any {
         if (!data || data.length  < 1) return ''
         let r = this.bcs.de('Perms', data);
@@ -390,8 +399,8 @@ export const MAX_NAME_LENGTH = 64;
 export const MAX_ENDPOINT_LENGTH = 1024;
 // export const OptionNone = (txb:TransactionBlock) : TransactionArgument => { return txb.pure([], BCS.U8) };
 
-export const IsValidDesription = (description:string) : boolean => { return description?.length <= MAX_DESCRIPTION_LENGTH }
-export const IsValidName = (name:string) : boolean => { if(!name) return false; return name.length <= MAX_NAME_LENGTH && name.length != 0 }
+export const IsValidDesription = (description:string) : boolean => { return description.length <= MAX_DESCRIPTION_LENGTH } 
+export const IsValidName = (name?:string) : boolean => { if(!name) return false; return name.length <= MAX_NAME_LENGTH && name.length != 0 }
 export const IsValidName_AllowEmpty = (name:string) : boolean => { return name.length <= MAX_NAME_LENGTH }
 export const IsValidEndpoint = (endpoint:string) : boolean => { 
     return (endpoint.length > 0 && endpoint.length <= MAX_ENDPOINT_LENGTH && isValidHttpUrl(endpoint)) ;
@@ -402,6 +411,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 {