wowok 1.6.63 → 1.6.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.6.63",
+  "version": "1.6.64",
   "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/agent_call/call.ts

@@ -11,13 +11,15 @@ import { MultiGetObjectsParams } from '@mysten/sui/client';
 import { Permission, Permission_Entity, Permission_Index, PermissionIndex, UserDefinedIndex } from '../permission';
 import { BCS } from '@mysten/bcs';
 import { PermissionAnswerItem, PermissionIndexType } from '../permission';
-import { Entity } from '../entity';
+import { Entity, Entity_Info } from '../entity';
 import { Repository, Repository_Policy, Repository_Policy_Data, Repository_Policy_Data2, Repository_Policy_Data_Remove, Repository_Policy_Mode, } from '../repository';
 import { Demand } from '../demand';
 import { Machine, Machine_Forward, Machine_Node } from '../machine';
 import { BuyRequiredEnum, Customer_RequiredInfo, DicountDispatch, Service, Service_Buy, Service_Guard_Percent, Service_Sale, WithdrawPayee } from '../service';
 import { DepositParam, Treasury, Treasury_WithdrawMode, WithdrawParam } from '../treasury';
-import { Arbitration, VotingGuard } from '../arbitration';
+import { Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee } from '../arbitration';
+import { Deliverable, ParentProgress, Progress, ProgressNext } from '../progress';
+import { MarkName, Resource } from '../resource';
 
 export interface CallBase {
     object: string | 'new';
@@ -66,6 +68,13 @@ export interface CallMachine extends CallBase { //@ todo self-owned node operate
         | {op:'remove pair'; pairs: {prior_node_name:string; node_name:string}[]}
         | {op:'add forward'; data: {prior_node_name:string; node_name:string; forward:Machine_Forward; threshold?:number; old_need_remove?:string}[]}
         | {op:'remove forward'; data:{prior_node_name:string; node_name:string; forward_name:string}[]}
+    progress_new?: {task_address?:string; };
+    progress_context_repository?: {progress:string; repository:string};
+    progress_parent?: {progress:string, parent?:ParentProgress};
+    progress_task?: {progress:string; task:string};
+    progress_namedOperator?: {progress:string; data:{name:string, operator:string[]}[]};
+    progress_hold?: {progress:string; data:ProgressNext; bHold:boolean; adminUnhold?:boolean};
+    progress_next?: {progress:string; data:ProgressNext; deliverable:Deliverable};
 }       
 
 export interface CallService extends CallBase {
@@ -74,7 +83,6 @@ export interface CallService extends CallBase {
     bPublished?: boolean;
     description?: string;
     gen_discount?: DicountDispatch[];
-    buy?: {buy_items:Service_Buy[], coin_object?:string, discount?:string, machine?:string, customer_info_crypto?: Customer_RequiredInfo}
     arbitration: {op:'set' | 'add'; arbitrations:{address:string, token_type:string}[]} 
         | {op:'removeall'} | {op:'remove', addresses:string[]};
     buy_guard?: string;
@@ -83,7 +91,7 @@ export interface CallService extends CallBase {
         | {op:'removeall'} | {op:'remove', addresses:string[]};
     machine?: string;
     payee_treasury?:string;
-    clone_new?: {token_type_new?:string};
+    clone?: {token_type_new?:string};
     repository: {op:'set' | 'add' | 'remove' ; repositories:string[]} | {op:'removeall'};
     withdraw_guard?: {op:'add' | 'set'; guards:Service_Guard_Percent[]} 
         | {op:'removeall'} | {op:'remove', addresses:string[]};
@@ -92,6 +100,7 @@ export interface CallService extends CallBase {
     customer_required_info?: {pubkey:string; required_info:(string | BuyRequiredEnum)[]};
     sales: {op:'add', sales:Service_Sale[]} | {op:'remove'; sales_name:string[]}
     crypto_pubkey?: string;
+    order_new?: {buy_items:Service_Buy[], coin_object?:string, discount?:string, machine?:string, customer_info_crypto?: Customer_RequiredInfo}
     order_required_info?: {order:string; info:Customer_RequiredInfo};
     order_refund?: {order:string; guard?:string;} | {order:string; arb:string; arb_token_type:string}; // guard address
     order_withdrawl?: {order:string; data:WithdrawPayee}; // guard address
@@ -120,6 +129,23 @@ export interface CallArbitration extends CallBase {
     usage_guard?: string;
     withdraw_treasury?: string;
     voting_guard?: {op:'add' | 'set'; data:VotingGuard[]} | {op:'remove', guards:string[]} | {op:'removeall'};
+    arb_new?: Dispute; // dispute an order, and a new Arb launched.
+    arb_withdraw_fee?: {arb:string; data:WithdrawFee};
+    arb_vote?: Vote;
+    arb_arbitration?: Feedback;
+}
+
+export interface CallPersonal extends CallBase {
+    information?: Entity_Info;
+    transfer_to?: string;
+    marks?: {op:'add mark'; data:{mark_name:string; address:string[]}}
+        | {op:'add address'; data:{address:string; mark_name:string[]}} 
+        | {op:'remove mark'; data:{mark_name:string; address:string[]}}
+        | {op:'remove address'; data:{address:string; mark_name:string[]}}
+        | {op:'clear mark'; mark_name:string};
+    tags?: {op:'add'; data:{address:string; nick_name:string; tags:string[]}}
+        | {op:'remove'; address:string};
+    close?: boolean; // close a personal resource
 }
 
 export namespace Call {
@@ -416,6 +442,37 @@ export namespace Call {
                         break;
                     }
             }
+            if (call?.progress_new !== undefined) {
+                Progress?.New(txb, call?.object, permission??call?.permission, call?.progress_new.task_address, passport).launch();
+            }
+            if (call?.progress_context_repository !== undefined) {
+                Progress.From(txb, call?.object, permission??call?.permission, call?.progress_context_repository.progress)
+                    .set_context_repository(call?.progress_context_repository.repository, passport)
+            }
+            if (call?.progress_namedOperator !== undefined) {
+                const p = Progress.From(txb, call?.object, permission??call?.permission, call?.progress_namedOperator.progress);
+                call.progress_namedOperator.data.forEach(v => p.set_namedOperator(v.name, v.operator, passport));
+            }
+            if (call?.progress_parent !== undefined) {
+                if (call.progress_parent.parent) {
+                    Progress.From(txb, call?.object, permission??call?.permission, call?.progress_parent.progress).parent(call.progress_parent.parent);
+                } else {
+                    Progress.From(txb, call?.object, permission??call?.permission, call?.progress_parent.progress).parent_none();
+                }
+            }
+            if (call?.progress_task !== undefined) {
+                Progress.From(txb, call?.object, permission??call?.permission, call?.progress_task.progress).bind_task(call.progress_task.task, passport)
+            }
+            if (call?.progress_hold !== undefined) {
+                if (call?.progress_hold.adminUnhold) {
+                    Progress.From(txb, call?.object, permission??call?.permission, call?.progress_hold.progress).unhold(call.progress_hold.data, passport)
+                } else {
+                    Progress.From(txb, call?.object, permission??call?.permission, call?.progress_hold.progress).hold(call.progress_hold.data, call.progress_hold.bHold)
+                }
+            }
+            if (call?.progress_next !== undefined) {
+                Progress.From(txb, call?.object, permission??call?.permission, call?.progress_next.progress).next(call.progress_next.data, call.progress_next.deliverable, passport)
+            }
             if (permission) {
                 permission.launch();
             }
@@ -463,8 +520,8 @@ export namespace Call {
             if (call?.bPublished) {
                 obj.publish(passport)
             }
-            if (call?.clone_new !== undefined) {
-                obj.clone(call.clone_new?.token_type_new, true, passport)
+            if (call?.clone !== undefined) {
+                obj.clone(call.clone?.token_type_new, true, passport)
             }
             if (call?.machine !== undefined) {
                 obj.set_machine(call.machine, passport)
@@ -573,25 +630,25 @@ export namespace Call {
                         break;
                 }
             }
-            if (call?.buy !== undefined) {
+            if (call?.order_new !== undefined) {
                 let b = BigInt(0); let coin : any;
-                call.buy.buy_items.forEach(v => {
+                call.order_new.buy_items.forEach(v => {
                     b += BigInt(v.max_price) * BigInt(v.count)
                 })
                 if (b > BigInt(0)) {
                     if (call?.type_parameter === '0x2::sui::SUI' || call?.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
                         coin = txb.splitCoins(txb.gas, [b])[0];
-                    } else if (call?.buy.coin_object) {
-                        coin = txb.splitCoins(call.buy.coin_object, [b])[0];
+                    } else if (call?.order_new.coin_object) {
+                        coin = txb.splitCoins(call.order_new.coin_object, [b])[0];
                     }                    
                 }
 
                 if (coin) {
                     //@ crypto tools support
-                    obj.buy(call.buy.buy_items, coin, call.buy.discount, call.buy.machine, call.buy.customer_info_crypto, passport)                    
+                    obj.buy(call.order_new.buy_items, coin, call.order_new.discount, call.order_new.machine, call.order_new.customer_info_crypto, passport)                    
                 }
             }
-            if (call?.order_payer !== undefined) {
+            if (call?.order_payer !== undefined && obj) {
                 obj.change_order_payer(call?.order_payer.order, call.order_payer.payer_new)
             }
             if (call?.order_agent !== undefined) {
@@ -742,6 +799,19 @@ export namespace Call {
                 }
             }
             
+            if (call?.arb_new !== undefined) {
+                obj.dispute(call.arb_new, passport)
+            }
+            if (call?.arb_arbitration !== undefined) {
+                obj.arbitration(call.arb_arbitration, passport)
+            }
+            if (call?.arb_vote !== undefined) {
+                obj.vote(call.arb_vote, passport)
+            }
+            if (call?.arb_withdraw_fee !== undefined) {
+                obj.withdraw_fee(call.arb_withdraw_fee.arb, call.arb_withdraw_fee.data, passport)
+            }
+
             if (withdraw_treasury) {
                 withdraw_treasury.launch();
             }
@@ -753,4 +823,72 @@ export namespace Call {
             }
         }
     }
+
+    export const personal = (call: CallPersonal, txb:TransactionBlock) => {
+        let obj : Resource | undefined ; let entity: Entity = Entity.From(txb);
+        if (call.object === 'new') {
+            obj = Resource.From(txb, entity.create_resource2());
+        } else {
+            if (IsValidAddress(call.object)) {
+                obj = Resource.From(txb, call.object)
+                if (call?.close) {
+                    entity.destroy_resource(obj)
+                    return ; //@ return 
+                }
+            }
+        }
+
+        if (call?.information !== undefined ) {
+            entity.update(call.information)
+        }
+
+        if (obj?.get_object()) {
+            if (call?.marks !== undefined) {
+                switch(call.marks.op) {
+                    case 'add address':
+                        obj.add2(call.marks.data.address, call.marks.data.mark_name)
+                        break;
+                    case 'add mark':
+                        if (call.marks.data.mark_name === MarkName.DislikeName || call.marks.data.mark_name === MarkName.LikeName) {
+                            const n = call.marks.data.mark_name;
+                            call.marks.data.address.forEach(v => entity.mark(obj, v, n))
+                        } else {
+                            obj.add(call.marks.data.mark_name, call.marks.data.address)
+                        }
+                        break;
+                    case 'clear mark':
+                        obj.remove(call.marks.mark_name, [], true)
+                        break;
+                    case 'remove address':
+                        obj.remove2(call.marks.data.address, call.marks.data.mark_name)
+                        break;
+                    case 'remove mark':
+                        if (call.marks.data.mark_name === MarkName.DislikeName || call.marks.data.mark_name === MarkName.LikeName) {
+                            const n = call.marks.data.mark_name;
+                            call.marks.data.address.forEach(v => entity.mark(obj, v, n))
+                        } else {
+                            obj.remove(call.marks.data.mark_name, call.marks.data.address)
+                        }
+                        break;
+                }
+            }
+            if (call?.tags !== undefined) {
+                switch(call.tags.op) {
+                    case 'add':
+                        obj.add_tags(call.tags.data.address, call.tags.data.nick_name, call.tags.data.tags)
+                        break;
+                    case 'remove':
+                        obj.remove_tags(call.tags.address)
+                        break;
+                }
+            }
+            if (call?.transfer_to !== undefined) {
+                entity.transfer_resource(obj, call.transfer_to);
+            }
+
+            if (call.object === 'new') {
+                obj.launch();
+            }
+        }
+    }
 }

package/src/agent_query/events.ts

@@ -56,21 +56,21 @@ export interface EventAnswer {
 
 export namespace EVENT_QUERY {
     export const newArbEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
-        return await queryEvents(Protocol.Instance().Package('wowok') + '::arb::NewArbEvent', option)
+        return await queryEvents(Protocol.Instance().package('wowok') + '::arb::NewArbEvent', option)
     }
     export const presentServiceEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
-        return await queryEvents(Protocol.Instance().Package('wowok') + '::demand::PresentEvent', option)
+        return await queryEvents(Protocol.Instance().package('wowok') + '::demand::PresentEvent', option)
     }
     export const newProgressEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
-        return await queryEvents(Protocol.Instance().Package('wowok') + '::progress::NewProgressEvent', option)
+        return await queryEvents(Protocol.Instance().package('wowok') + '::progress::NewProgressEvent', option)
     }
     export const newOrderEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
-        return await queryEvents(Protocol.Instance().Package('wowok') + '::order::NewOrderEvent', option)
+        return await queryEvents(Protocol.Instance().package('wowok') + '::order::NewOrderEvent', option)
     }
     const queryEvents = async(type:string, option?:EventQueryOption) : Promise<EventAnswer> => {
         const res = await Protocol.Client().queryEvents({query:{MoveEventType:type}, cursor:option?.cursor, limit:option?.limit, order:option?.order});
         const data = res?.data?.map((v:any) => {
-            if (v?.packageId === Protocol.Instance().Package('wowok')) {
+            if (v?.packageId === Protocol.Instance().package('wowok')) {
                 if (v?.type?.includes('::order::NewOrderEvent')) {
                     return {
                         id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'NewOrderEvent',

package/src/agent_query/objects.ts

@@ -11,6 +11,7 @@ import { Machine_Node, Machine } from '../machine';
 import { Progress, History } from '../progress';
 import { ERROR, Errors } from '../exception';
 import { IsValidAddress, Bcs } from '../utils';
+import { WowokCache, OBJECT_KEY } from '../cache';
 export interface ObjectBase {
     object: string;
     type?: string | 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' |
@@ -20,7 +21,9 @@ export interface ObjectBase {
     type_raw?: string;
     owner?: any;
     version?: string;
+    cache_expire?: number;
 }
+
 export interface ObjectPermission extends ObjectBase {
     builder: string;
     admin: string[];
@@ -248,11 +251,18 @@ export interface TableItem_ResourceMark extends ObjectBase {
     objects: string[];
 }
 
+export enum CacheType {
+    localStorage = 'localStorage', // for explorer
+    memoryStorage = 'memoryStorage', // for console
+}
+
+const MEMORY_STORAGE = new Map<string, string>();
 export interface ObjectsQuery {
     objects: string[];
     showType?: boolean;
     showContent?: boolean;
     showOwner?: boolean;
+    no_cache?: boolean;
 }
 export interface ObjectsAnswer {
     objects?: ObjectBase[];
@@ -280,6 +290,10 @@ interface TableItemQuery {
     key: {type:string, value:unknown};
 }
 
+export interface CacheData {
+    expire: number;
+    data: string | any; 
+}
 export namespace OBJECT_QUERY {
     /* json: ObjectsQuery string */
     export const objects_json = async (json:string) : Promise<string> => {
@@ -302,17 +316,65 @@ export namespace OBJECT_QUERY {
     }
 
     export const objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
+        const ret:ObjectBase[] = []; let bCached = true; const time = new Date().getTime();
+        const cache = WowokCache.Instance().get();
+        if (!query?.no_cache && cache) {
+            try {
+                for (let i = 0; i < query.objects.length; ++i) {
+                    let data = cache.load(OBJECT_KEY(query.objects[i]))
+                    
+                    if (data) {
+                        const r:CacheData = JSON.parse(data);
+                        const d = data2object(JSON.parse(r.data));
+                        d.cache_expire = r.expire;
+    
+                        if (r?.expire <= time && (query.showOwner || query.showContent)) {
+                            bCached = false; 
+                            break;
+                        }
+    
+                        ret.push(d);                        
+                    } else {
+                        bCached = false; break;
+                    }
+                }
+                
+                if (bCached) {
+                    return {objects:ret}
+                }
+            } catch(e) {
+                console.log(e);
+            }
+        } 
+
         if (query.objects.length > 0) {
             const res = await Protocol.Client().multiGetObjects({ids:query.objects, 
                 options:{showContent:query.showContent, showType:query.showType, showOwner:query.showOwner}});
-            console.log(JSON.stringify(res))
+            const now = new Date().getTime(); 
+            const cache = WowokCache.Instance().get();
+            
+            if (cache) {
+                res.forEach((i) => { // save
+                    try {
+                        if (i?.data) {
+                            const type_raw:string | undefined = i.data?.type ?? ((i.data?.content as any)?.type ?? undefined);
+                            const type:string | undefined = type_raw ? Protocol.Instance().object_name_from_type_repr(type_raw) : undefined;
+                            const expire = (type === 'Guard' || type === 'Payment') ? 86400000000 : cache.expire_time(); // guard & payment immutable
+                            const r:CacheData = {expire:expire+now, data:JSON.stringify(i.data)}
+                            cache.save(OBJECT_KEY(i.data.objectId), JSON.stringify(r));
+                        }                            
+                    } catch(e) { console.log(e) }
+                })                
+            }
+
             return {objects:res.map(v=>data2object(v?.data))}                
         } 
         return {objects:[]}
     }
+
     export const entity = async (address:string) : Promise<ObjectEntity> => {
         if (!IsValidAddress(address))  ERROR(Errors.IsValidAddress, 'entity.address')
-        const res = await Protocol.Client().getDynamicFieldObject({parentId:Protocol.Instance().EntityObject(), name:{type:'address', value:address}});
+        const res = await Protocol.Client().getDynamicFieldObject({parentId:Protocol.Instance().objectEntity(), name:{type:'address', value:address}});
         return data2object(res?.data) as ObjectEntity
     }
 
@@ -350,7 +412,7 @@ export namespace OBJECT_QUERY {
         if (typeof(repository_object) !== 'string') {
             repository_object = repository_object.object;
         }
-        return await tableItem({parent:repository_object, key:{type:Protocol.Instance().Package('wowok')+'::repository::DataKey', value:{id:address, key:name}}})
+        return await tableItem({parent:repository_object, key:{type:Protocol.Instance().package('wowok')+'::repository::DataKey', value:{id:address, key:name}}})
     }
     export const tableItemQuery_ResourceMark = async (resource_object:string | ObjectResouorce, name:string) : Promise<ObjectBase> => {
         return await tableItem(tableItemQuery_byString(resource_object, name))
@@ -379,7 +441,7 @@ export namespace OBJECT_QUERY {
         return data2object(res?.data)
     }
 
-    function data2object(data?:any) : ObjectBase {
+    export function data2object(data?:any) : ObjectBase {
         const content = (data?.content as any)?.fields;
         const id = data?.objectId ?? (content?.id?.id ?? undefined);
         const type_raw:string | undefined = data?.type ?? (data?.content?.type ?? undefined);

package/src/agent_query/permission.ts

@@ -48,13 +48,10 @@ export namespace PERMISSION_QUERY {
         if (perm === Permission.PERMISSION_ADMIN || perm === Permission.PERMISSION_OWNER_AND_ADMIN) {
             return {who:query.address, admin:true, owner:perm%2===1, items:[], object:query.permission_object}
         } else {
-            const perms = Bcs.getInstance().de('vector<u64>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
-            const guards = Bcs.getInstance().de_guards(Uint8Array.from((res.results as any)[0].returnValues[2][0]));
-            const items: PermissionAnswerItem[] = [];
-            for(let i = 0; i < perms.length; ++i) {
-                items.push({query:perms[i], permission:true, guard:guards[i] ? ('0x'+guards[i]) : undefined})
-            }
-            return {who:query.address, admin:false, owner:perm%2===1, items:items, object:query.permission_object};  
+            const perms = Bcs.getInstance().de_perms(Uint8Array.from((res.results as any)[0].returnValues[1][0]));
+            return {who:query.address, admin:false, owner:perm%2===1, items:perms.map((v:any)=>{
+                return {query:v?.index, permission:true, guard:v?.guard}
+            }), object:query.permission_object};  
         }
     }
 }