wowok 1.6.59 → 1.6.60

package/package.json

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

@@ -1,10 +1,10 @@
 /**
- * Provide a JSON call interface for AI
+ * Provide a call interface for AI
  * 
  */
 
 import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
-import { Protocol, } from '../protocol';
+import { DemandObject, PermissionObject, Protocol, ServiceObject, } from '../protocol';
 import { Bcs, IsValidAddress, IsValidArgType, IsValidU64, parseObjectType, IsValidU8 } from '../utils'
 import { Errors, ERROR}  from '../exception'
 import { MultiGetObjectsParams } from '@mysten/sui/client';
@@ -13,22 +13,27 @@ import { BCS } from '@mysten/bcs';
 import { PermissionAnswerItem, PermissionIndexType } from '../permission';
 import { Entity } from '../entity';
 import { Repository_Policy_Mode } from '../repository';
+import { LargeNumberLike } from 'crypto';
+
+export type FUNC_TYPE = string | number | boolean | 'DemandObject' | 'PermissionObject';
 export interface AgentFuncParameter {
-    type: 'string' | 'number' | 'boolean' | 'struct' ;
     name: string;
-    description: string;
+    description?: string;
     required: boolean;
+    type: FUNC_TYPE;
+    value?: FUNC_TYPE;
 }
 
 export interface AgentFuncReturn {
-    type: 'string' | 'number' | 'boolean' | 'struct' ;
+    type: DemandObject ;
     name: string;
     description: string;
 }
+
 export interface AgentFunc {
     name: string;
-    description: string;
-    module: string;
+    description?: string;
+    module?: string;
     permissionIndex: number;
     parameter: AgentFuncParameter[];
     return?: AgentFuncReturn;
@@ -36,12 +41,12 @@ export interface AgentFunc {
 
 export const AGENT_FUNC: AgentFunc[] = [
     {permissionIndex:PermissionIndex.repository, name:'Repository', description:'Launch new Repository', module: 'repository', parameter:[
-        {type:'string', name:'permission', description:'permission', required:true},
-        {type:'number', name:'mode', description:'mode', required:false}, 
+        {type: 'PermissionObject' , name:'permission', description:'Permission address or object', required:true},
+        {type: '"Relax mode" or  "Strict mode"', name:'mode', description:'Relax mode: Allows entry of data other than policy. Used for informal, non-consensus situations.\nStrict mode: Prohibits entry of data beyond policy. Used in formal, fully consensus contexts.', required:false}, 
     ]},
     {permissionIndex:PermissionIndex.repository_description, name:'Description', description:'Set Repository description', module: 'repository', parameter:[
-        {type:'string', name:'object', description:'object', required:true},
-        {type:'string', name:'description', description:'description', required:true},
+        {type:'DemandObject', name:'demand', description:'Demand address or object', required:true},
+        {type:'string', name:'description', description:'Demand description', required:true},
     ]},
     {permissionIndex:PermissionIndex.repository_policy_mode, name:'Policy mode', description:'Set Repository policy mode', module: 'repository', parameter:[]},
     {permissionIndex:PermissionIndex.repository_policies, name:'Policy', description:'Add/Remove/Edit Repository policy', module: 'repository', parameter:[]},
@@ -115,6 +120,6 @@ export const AGENT_FUNC: AgentFunc[] = [
     {permissionIndex:PermissionIndex.arbitration_withdraw, name: 'Withdraw', description:'Withdraw the arbitration fee', module: 'arbitration', parameter:[]},
     {permissionIndex:PermissionIndex.arbitration_treasury, name: 'Withdraw', description:'Set Treasury that fees was collected at the time of withdrawal', module: 'arbitration', parameter:[]},
 ]
-export class AgentCall {
+export namespace Call {
     
 }

package/src/agent_query/events.ts

@@ -0,0 +1,100 @@
+
+/**
+ * Provide AI with Basic WoWok event queries: 
+ * for real-time detail tracking.
+ */
+
+import { Protocol } from '../protocol';
+
+export interface EventQueryOption {
+    /** optional paging cursor */
+    cursor?: {eventSeq: string; txDigest: string} | null | undefined;
+    /** maximum number of items per page, default to [QUERY_MAX_RESULT_LIMIT] if not specified. */
+    limit?: number | null | undefined;
+    /** query result ordering, default to false (ascending order), oldest record first. */
+    order?: 'ascending' | 'descending' | null | undefined;
+}
+
+export interface EventBase {
+    id: {eventSeq: string; txDigest: string};
+    sender: string;
+    type: string | 'NewArbEvent' | 'NewOrderEvent' | 'NewProgressEvent' | 'PresentServiceEvent';
+    type_raw: string;
+    time: string;
+}
+
+export interface NewArbEvent extends EventBase {
+    arb: string,
+    arbitration: string,
+    order: string,
+}
+
+export interface NewOrderEvent extends EventBase {
+    order: string,
+    service: string,
+    progress?: string | null,
+    amount: string,
+}
+
+export interface NewProgressEvent extends EventBase {
+    progress: string,
+    machine: string,
+    task?: string | null,
+}
+
+export interface PresentServiceEvent extends EventBase {
+    demand: string,
+    service: string,
+    recommendation: string,
+}
+
+export interface EventAnswer {
+    data: EventBase[];
+    hasNextPage: boolean;
+    nextCursor?: {eventSeq: string; txDigest: string} | null;
+}
+
+export namespace EVENT_QUERY {
+    export const newArbEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
+        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)
+    }
+    export const newProgressEvents = async(option?:EventQueryOption) : Promise<EventAnswer> => {
+        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)
+    }
+    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?.type?.includes('::order::NewOrderEvent')) {
+                    return {
+                        id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'NewOrderEvent',
+                        order: v?.parsedJson?.object, service: v?.parsedJson?.service, progress: v?.parsedJson?.progress, amount: v?.parsedJson?.amount
+                    } as NewOrderEvent
+                } else if (v?.type?.includes('::demand::PresentEvent')) {
+                    return {
+                        id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'NewOrderEvent',
+                        demand:v?.parsedJson?.object, service: v?.parsedJson?.service, recommendation:v?.parsedJson?.tips
+                    } as PresentServiceEvent
+                } else if (v?.type?.includes('::progress::NewProgressEvent')) {
+                    return {
+                        id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'NewOrderEvent',
+                        progress:v?.parsedJson?.object, machine: v?.parsedJson?.machine, task:v?.parsedJson?.task
+                    } as NewProgressEvent
+                } else if (v?.type?.includes('::arb::NewArbEvent')) {
+                    return {
+                        id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'NewOrderEvent',
+                        arb:v?.parsedJson?.object, arbitration:v?.parsedJson?.arbitration, order:v?.parsedJson?.order
+                    } as NewArbEvent
+                } 
+            }
+            return {id: v?.id, time: v?.timestampMs, type_raw:v?.type, sender:v?.sender, type:'',}
+        })
+        return {data:data, hasNextPage:res?.hasNextPage, nextCursor:res?.nextCursor}
+    }
+}

package/src/agent_query/{object.ts → objects.ts}

@@ -1,5 +1,5 @@
 /**
- * Provide a JSON query interface for AI
+ * Provide a query interface for AI
  * 
  */
 
@@ -9,9 +9,14 @@ import { Repository_Type, Repository_Policy_Mode, Repository_Policy } from '../r
 import { Service_Discount_Type, Service_Sale } from '../service';
 import { Machine_Node, Machine } from '../machine';
 import { Progress, History } from '../progress';
+import { ERROR, Errors } from '../exception';
+import { IsValidAddress, Bcs } from '../utils';
 export interface ObjectBase {
     object: string;
-    type?: string;
+    type?: string | 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' |
+        'Entity' | 'Permission' | 'Resource' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
+        'TableItem_DemandPresenter' | 'TableItem_MachineNode' | 'TableItem_ServiceSale' | 'TableItem_TreasuryHistory' | 'TableItem_ArbVote' |
+        'TableItem_RepositoryData' | 'TableItem_ResourceMark';
     type_raw?: string;
     owner?: any;
     version?: string;
@@ -24,7 +29,7 @@ export interface ObjectPermission extends ObjectBase {
     biz_permission: {id:number; name:string}[];
 }
 
-export interface PermissionTable_Entity extends ObjectBase {
+export interface TableItem_PermissionEntity extends ObjectBase {
     entity: string;
     permission: {id:number; guard?:string|null}[];
 }
@@ -39,7 +44,7 @@ export interface ObjectDemand extends ObjectBase {
     bounty: {object:string; balance:string; type:string}[];
 }
 
-export interface DemandTable_Presenter extends ObjectBase {
+export interface TableItem_DemandPresenter extends ObjectBase {
     service: string;
     presenter: string;
     recommendation: string;
@@ -55,7 +60,7 @@ export interface ObjectMachine extends ObjectBase {
     node_count: number;
 }
 
-export interface MachineTable_Node extends ObjectBase {
+export interface TableItem_MachineNode extends ObjectBase {
     node: Machine_Node;
 }
 
@@ -86,7 +91,7 @@ export interface ObjectProgress extends ObjectBase {
     namedOperator: {name:string, operator:string[]}[];
 }
 
-export interface ProgressTable_History extends ObjectBase {
+export interface TableItem_ProgressHistory extends ObjectBase {
     history: History;
 }
 
@@ -108,7 +113,7 @@ export interface ObjectService extends ObjectBase {
     customer_required_info?: {pubkey:string; required_info:string[]};
 }
 
-export interface ServiceTable_Sale extends ObjectBase {
+export interface TableItem_ServiceSale extends ObjectBase {
     item: Service_Sale;
 }
 export interface ObjectOrder extends ObjectBase {
@@ -135,7 +140,7 @@ export interface ObjectTreasury extends ObjectBase {
     balance: string;
     history_count: number;
 }
-export interface TreasuryTable_History extends ObjectBase {
+export interface TableItem_TreasuryHistory extends ObjectBase {
     id: number,
     operation: Treasury_Operation,
     signer: string,
@@ -165,7 +170,7 @@ export interface ObjectArb extends ObjectBase {
     proposition: {proposition:string, votes:string};
     voted_count: number;
 }
-export interface ArbTable_Vote extends ObjectBase {
+export interface TableItem_ArbVote extends ObjectBase {
     singer: string;
     vote: number[];
     weight: string;
@@ -180,7 +185,7 @@ export interface ObjectRepository extends ObjectBase {
     policy: Repository_Policy[];
     data_count: number;
 }
-export interface RepositoryTable_Data extends ObjectBase {
+export interface TableItem_RepositoryData extends ObjectBase {
     address: string;
     key: string;
     data: Uint8Array;
@@ -211,6 +216,37 @@ export interface ObjectGuard extends ObjectBase {
     input: Uint8Array;
     identifier: {id:number; bWitness:boolean; value:Uint8Array}[];
 }
+export interface ObjectEntity extends ObjectBase {
+    address: string; 
+    like: number;
+    dislike: number;
+
+    name?: string;
+    description?: string;
+    avatar?: string;
+    x?: string;
+    discord?: string;
+
+    homepage?: string;
+    resource_object?: string | null;
+    lastActive_digest?: string; 
+}
+
+export interface ObjectResouorce_Tag {
+    object: string;
+    nick_name: string;
+    tags: string[];
+}
+
+export interface ObjectResouorce extends ObjectBase {
+    marks_count: number;
+    tags: ObjectResouorce_Tag[];
+}
+
+export interface TableItem_ResourceMark extends ObjectBase {
+    mark_name: string;
+    objects: string[];
+}
 
 export interface ObjectsQuery {
     objects: string[];
@@ -218,7 +254,6 @@ export interface ObjectsQuery {
     showContent?: boolean;
     showOwner?: boolean;
 }
-
 export interface ObjectsAnswer {
     objects?: ObjectBase[];
     error?: string;
@@ -229,89 +264,122 @@ export interface TableQuery {
     cursor?: string | null | undefined;
     limit?: number | null | undefined;
 }
-
+export interface TableAnswerItem {
+    key: {type:string; value:unknown};
+    object: string;
+    version: string;
+}
 export interface TableAnswer {
-    items: TableItem[];
+    items: TableAnswerItem[];
     nextCursor: string | null;
     hasNextPage: boolean;
 }
 
-export interface TableItemQuery {
+interface TableItemQuery {
     parent: string;
-    name: {type:string; value:string};
-}
-export interface TableItemAnwser {
-    object: string;
-    type?: string;
-    version?: string;
-    owner?: any;
-}
-
-export interface TableItem {
-    name: {type:string; value:string};
-    object: string;
-    version: string;
-    error?: string;
+    key: {type:string, value:unknown};
 }
 
-export const PermissionTable_Type = 'address';
-
-export class OBJECT_QUERY {
+export namespace OBJECT_QUERY {
     /* json: ObjectsQuery string */
-    static objects_json = async (json:string) : Promise<string> => {
+    export const objects_json = async (json:string) : Promise<string> => {
         try {
             const q : ObjectsQuery = JSON.parse(json);
-            return JSON.stringify(await OBJECT_QUERY.objects(q));
+            return JSON.stringify({data:await objects(q)});
         } catch (e) {
             return JSON.stringify({error:e?.toString()})
         }
     }
 
     /* json: TableQuery string */
-    static table_json = async (json:string) : Promise<string> => {
+    export const table_json = async (json:string) : Promise<string> => {
         try {
             const q : TableQuery = JSON.parse(json);
-            return JSON.stringify(await OBJECT_QUERY.table(q));
+            return JSON.stringify({data:await table(q)});
         } catch (e) {
             return JSON.stringify({error:e?.toString()})
         }
     }
 
-    /* json: TableQuery string*/
-    static tableItem_json = async (json:string) : Promise<string> => {
-        try {
-            const q : TableItemQuery = JSON.parse(json);
-            return JSON.stringify(await OBJECT_QUERY.tableItem(q));
-        } catch (e) {
-            return JSON.stringify({error:e?.toString()})
-        }
-    }
-
-    static objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
+    export const objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
         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))
-            return {objects:res.map(v=>this.data2object(v?.data))}                
+            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}});
+        return data2object(res?.data) as ObjectEntity
+    }
 
-    static table = async (query:TableQuery) : Promise<TableAnswer> => {
+    export const table = async (query:TableQuery) : Promise<TableAnswer> => {
         const res = await Protocol.Client().getDynamicFields({parentId:query.parent, cursor:query.cursor, limit:query.limit});
         return {items:res?.data?.map(v=>{
-            return {object:v.objectId, type:v.type, version:v.version, name:{
-                type:v.name.type, value:v.name.value?.toString() ?? ''
+            return {object:v.objectId, type:v.type, version:v.version, key:{
+                type:v.name.type, value:v.name.value
             }} 
         }), nextCursor:res.nextCursor, hasNextPage:res.hasNextPage}
     }
     
-    static tableItem = async (query:TableItemQuery) : Promise<TableItemAnwser> => {
-        const res = await Protocol.Client().getDynamicFieldObject({parentId:query.parent, name:{type:query.name.type, value:query.name.value}});
-        return {object:res.data?.objectId ??'', version:res.data?.version, owner:res.data?.owner}
+    export const queryTableItem_DemandPresenter = async (demand_object:string | ObjectDemand, address:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byAddress(demand_object, address))
+    }
+    export const queryTableItem_PermissionEntity = async (permission_object:string | ObjectDemand, address:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byAddress(permission_object, address))
+    }
+    export const queryTableItem_ArbVote = async (arb_object:string | ObjectDemand, address:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byAddress(arb_object, address))
+    }
+    export const tableItemQuery_MachineNode = async (machine_object:string | ObjectMachine, name:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byString(machine_object, name))
+    }
+    export const tableItemQuery_ServiceSale = async (service_object:string | ObjectService, name:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byString(service_object, name))
+    }
+    export const tableItemQuery_ProgressHistory = async (progress_object:string | ObjectProgress, index:BigInt) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byU64(progress_object, index))
+    }
+    export const tableItemQuery_TreasuryHistory = async (treasury_object:string | ObjectTreasury, index:BigInt) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byU64(treasury_object, index))
+    }
+    export const tableItemQuery_RepositoryData = async (repository_object:string | ObjectRepository, address:string, name:string) : Promise<ObjectBase> => {
+        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}}})
+    }
+    export const tableItemQuery_ResourceMark = async (resource_object:string | ObjectResouorce, name:string) : Promise<ObjectBase> => {
+        return await tableItem(tableItemQuery_byString(resource_object, name))
+    }
+
+    function tableItemQuery_byAddress(parent:string | ObjectDemand | ObjectPermission | ObjectArb, address:string) : TableItemQuery {
+        if (typeof(parent) !== 'string') {
+            parent = parent.object;
+        }
+        return {parent:parent, key:{type:'address', value:address}};
+    }
+    function tableItemQuery_byString(parent:string | ObjectMachine | ObjectService | ObjectResouorce, name:string) : TableItemQuery  {
+        if (typeof(parent) !== 'string') {
+            parent = parent.object;
+        }
+        return {parent:parent, key:{type:'0x1::string::String', value:name}};
+    }
+    function tableItemQuery_byU64 (parent:string | ObjectProgress | ObjectTreasury, index:BigInt) : TableItemQuery {
+        if (typeof(parent) !== 'string') {
+            parent = parent.object;
+        }
+        return {parent:parent, key:{type:'u64', value:index}};
+    }
+    const tableItem = async (query:TableItemQuery) : Promise<ObjectBase> => {
+        const res = await Protocol.Client().getDynamicFieldObject({parentId:query.parent, name:{type:query.key.type, value:query.key.value}});
+        return data2object(res?.data)
     }
 
-    private static data2object = (data?:any) : ObjectBase => {
+    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);
@@ -456,7 +524,15 @@ export class OBJECT_QUERY {
                     identifier:content?.constants?.map((v:any) => {
                         return {id:v?.fields?.identifier, bWitness:v?.fields?.bWitness, value:Uint8Array.from(v?.fields?.value)}
                     })
-                } as ObjectGuard;   
+                } as ObjectGuard;  
+            case 'Resource' :
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    marks_count:parseInt(content?.marks?.fields?.size),
+                    tags:content?.tags?.map((v:any) => {
+                        return {object:v?.fields?.object, nick_name:v?.fields?.nick, tags:v?.fields?.tags}
+                    })
+                } as ObjectResouorce;   
             }
         } 
         
@@ -468,48 +544,62 @@ export class OBJECT_QUERY {
                     return {
                         object:id, type:'DemandTable_Presenter', type_raw:type_raw, owner:owner, version:version,
                         service:content?.name, presenter:content?.value?.fields?.who, recommendation:content?.value?.fields?.tips
-                    } as DemandTable_Presenter;
+                    } as TableItem_DemandPresenter;
                 } else if (end.includes('::machine::NodePair>>>')) {
                     return {
                         object:id, type:'MachineTable_Node', type_raw:type_raw, owner:owner, version:version,
                         node:{name:content?.name, pairs:Machine.rpc_de_pair(content?.value)}
-                    } as MachineTable_Node;
+                    } as TableItem_MachineNode;
                 } else if (end.includes('::progress::History>')) {
                     return {
                         object:id, type:'ProgressTable_History', type_raw:type_raw, owner:owner, version:version,
                         history:Progress.rpc_de_history(content)
-                    } as ProgressTable_History;
+                    } as TableItem_ProgressHistory;
                 } else if (end.includes('::service::Sale>')) {
                     return {
                         object:id, type:'ServiceTable_Sale', type_raw:type_raw, owner:owner, version:version,
                         item:{item:content?.name, stock:content?.value?.fields?.stock, price:content?.value?.fields?.price,
                             endpoint:content?.value?.fields?.endpoint
                         }
-                    } as ServiceTable_Sale;
+                    } as TableItem_ServiceSale;
                 } else if (end.includes('::treasury::Record>')) {
                     return {
                         object:id, type:'TreasuryTable_History', type_raw:type_raw, owner:owner, version:version,
                         id: content?.name, payment:content?.value?.fields?.payment, signer:content?.value?.fields?.signer,
                         operation: content?.value?.fields?.op, amount: content?.value?.fields?.amount, time:content?.value?.fields?.time
-                    } as TreasuryTable_History;
+                    } as TableItem_TreasuryHistory;
                 } else if (end.includes('::arb::Voted>')) {
                     return {
                         object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
                         singer:content?.name, vote:content?.value?.fields?.agrees, time: content?.value?.fields?.time,
                         weight:content?.value?.fields?.weight
-                    } as ArbTable_Vote;
+                    } as TableItem_ArbVote;
                 } else if (end.includes('::permission::Perm>>')) {
                     return {
-                        object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                        object:id, type:'TableItem_PermissionEntity', type_raw:type_raw, owner:owner, version:version,
                         entity:content?.name, permission:content?.value?.map((v:any) => {
                             return {id:v?.fields.index, guard:v?.fields.guard}
                         })
-                    } as PermissionTable_Entity;
+                    } as TableItem_PermissionEntity;
                 } else if (end.includes('::repository::DataKey')) {
                     return {
-                        object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                        object:id, type:'TableItem_RepositoryData', type_raw:type_raw, owner:owner, version:version,
                         address:content?.name?.fields?.id, key:content?.name?.fields?.key, data:Uint8Array.from(content?.value)
-                    } as RepositoryTable_Data;
+                    } as TableItem_RepositoryData;
+                } else if (end.includes('::entity::Ent>')) {
+                    const info = Bcs.getInstance().de_entInfo(Uint8Array.from(content?.value?.fields?.avatar));
+                    return {
+                        object:id, type:'Entity', type_raw:type_raw, owner:owner, version:version,
+                        address:content?.name, like:content?.value?.fields?.like, dislike:content?.value?.fields?.dislike, 
+                        resource_object: content?.value?.fields?.resource, lastActive_digest: data?.previousTransaction,
+                        homepage:info?.homepage, name:info?.name, avatar:info?.avatar, x:info?.twitter, discord:info?.discord, 
+                        description:info?.description
+                    } as ObjectEntity;
+                } else if (end.includes('::resource::Addresses>')) {
+                    return {
+                        object:id, type:'Entity', type_raw:type_raw, owner:owner, version:version,
+                        mark_name:content?.name, objects:content?.value?.fields?.addresses
+                    } as TableItem_ResourceMark;
                 }
             }
         }

package/src/agent_query/permission.ts

@@ -1,6 +1,6 @@
 /**
- * Provide a JSON query interface for AI
- * 
+ * Provides permission lookup for an address: 
+ * not only the permission table, but also the administrator or Builder identity.
  */
 
 import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
@@ -9,25 +9,25 @@ import { Bcs, IsValidAddress} from '../utils'
 import { Errors, ERROR}  from '../exception'
 import { Permission } from '../permission';
 import { BCS } from '@mysten/bcs';
-import { PermissionAnswerItem, PermissionIndexType, PermissionAnswer } from '../permission';
+import { PermissionAnswerItem, PermissionAnswer } from '../permission';
 
 export interface PermissionQuery {
     permission_object: string;
     address: string;
 }
 
-export class PERMISSION_QUERY {
+export namespace PERMISSION_QUERY {
     /*json: PermissionQuery; return PermissionAnswer */
-    static permission_json = async (json:string) : Promise<string> => {
+    export const permission_json = async (json:string) : Promise<string> => {
         try {
             const q : PermissionQuery = JSON.parse(json);
-            return JSON.stringify(await PERMISSION_QUERY.permission(q));
+            return JSON.stringify({data:await permission(q)});
         } catch (e) {
             return JSON.stringify({error:e});
         }
     }
 
-    static permission = async (query:PermissionQuery) : Promise<PermissionAnswer> => {
+    export const permission = async (query:PermissionQuery) : Promise<PermissionAnswer> => {
         if (!IsValidAddress(query.permission_object)) {
             ERROR(Errors.IsValidAddress, 'permission.permission_object');
         }

package/src/index.ts

@@ -14,9 +14,9 @@ export * from './resource'
 export * from './treasury'
 export * from './payment'
 export * from './arbitration'
-export * from './agent_query/object'
+export * from './agent_query/objects'
 export * from './agent_query/permission'
-export * from './agent_query/entity'
+export * from './agent_query/events'
 
 // export * from './reward'
 // export * from './vote'

package/src/protocol.ts

@@ -163,7 +163,7 @@ export enum ContextType {
     TYPE_SIGNER  = 60,
     TYPE_CLOCK = 61,
     TYPE_GUARD = 62, // current guard address
-    TYPE_STACK_ADDRESS = 63, // object queried from current stack top
+    //TYPE_STACK_ADDRESS = 63, // object queried from current stack top
     TYPE_CONSTANT = 80,
 }
 interface ValueTypeString {
@@ -219,13 +219,13 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x7bb3672fb818b362703a2f2e0804c4cea6b5a23dc79920217088374450300f45",
-    wowok_origin:'0x7bb3672fb818b362703a2f2e0804c4cea6b5a23dc79920217088374450300f45' ,
+    wowok: "0x5091944f647fdcd1a5a90016933a9eac13b2c1dc41291d1ce31ed7a0cd664a02",
+    wowok_origin:'0x5091944f647fdcd1a5a90016933a9eac13b2c1dc41291d1ce31ed7a0cd664a02' ,
     base: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
     base_origin: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
 
-    wowok_object: '0x6f0b0c6d1d6b02e8589064c0c40d6aed105c5cc5ffece509111a8d308e3eb188',
-    entity_object: '0x42a28bf08b8373cc460b001eab9d9cd91c4285855bea0dc40116237de79870b8',
+    wowok_object: '0x6cfe6ee9f53b33eed11a6d4d1e09fb43278f222ced15aef7246243ecadf3c00f',
+    entity_object: '0x5469d38103ab78f91222338b489b512f9de86932edde064f7d2d77a6e78cf7a9',
     treasury_cap:'0x9f415c863f0c26103e70fc4a739fea479ff20544057a3c5665db16c0b8650f7c',
     oracle_object:'0x6c7d9b8ab0e9d21291e0128ca3e0d550b30f375f1e008381f2fbeef6753e6dcf',
 }
@@ -272,7 +272,8 @@ export class Protocol {
     static Client() : SuiClient {
         return  new SuiClient({ url: Protocol.Instance().NetworkUrl() });  
     }
-
+    
+    client() { return new SuiClient({url: this.NetworkUrl() })}
     UseNetwork(network:ENTRYPOINT=ENTRYPOINT.testnet) {
         this.network = network;
         switch(network) {

package/src/utils.ts

@@ -323,7 +323,7 @@ export class Bcs {
         return this.bcs.de('EntStruct', Uint8Array.from(struct_vec));
     }    
     de_entInfo(data:Uint8Array | undefined) : any {
-        if (!data || data.length === 0) return ''
+        if (!data || data.length === 0) return undefined
         let r = this.bcs.de('PersonalInfo', data);
         r.name = new TextDecoder().decode(Uint8Array.from(r.name));
         r.description = new TextDecoder().decode(Uint8Array.from(r.description));

package/src/agent_query/entity.ts

@@ -1,100 +0,0 @@
-/**
- * Provide a JSON query interface for AI
- * 
- */
-
-import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { Protocol, } from '../protocol';
-import { Bcs, IsValidAddress } from '../utils'
-import { Errors, ERROR}  from '../exception'
-import { Entity } from '../entity';
-
-
-export interface EntityQuery {
-    address: string;
-    showTags?: boolean;
-    showMarks?: boolean;
-}
-
-export interface EntityDetail {
-    name: string;
-    description: string;
-    avatar: string;
-    x: string;
-    discord: string;
-    homepage: string;
-}
-
-export interface ObjectTag {
-    object: string;
-    nick_name: string;
-    tags: string[];
-}
-
-export interface ObjectMark {
-    mark_name: string;
-    objects: string[];
-}
-
-export interface EntityAnswer {
-    address: string; 
-    like: number;
-    dislike: number;
-    details: EntityDetail;
-    resource_object?: string;
-    lastActive_digest?: string; 
-    marks?: ObjectMark[];
-    tags?: ObjectTag[];
-}
-
-export class ENTITY_QUERY {
-    /*json: EntityQuery; return EntityAnswer */
-    static entity_json = async (json:string) : Promise<string> => {
-        try {
-            const q : EntityQuery = JSON.parse(json);
-            return JSON.stringify(await ENTITY_QUERY.entity(q));
-        } catch (e) {
-           return JSON.stringify({error:e}); 
-        }
-    }
-
-    static entity = async (query:EntityQuery) : Promise<EntityAnswer> => {
-        if (!IsValidAddress(query.address)) {
-            ERROR(Errors.IsValidAddress, 'entity.address')
-        }
-
-        const txb = new TransactionBlock();
-        Entity.From(txb).query_ent(query.address);
-
-        const res = await Protocol.Client().devInspectTransactionBlock({sender:query.address, transactionBlock:txb});
-        if (!res.results || res.results?.length !== 1 || res.results[0].returnValues?.length !== 1 )  {
-            ERROR(Errors.Fail, 'entity.fail')
-        }
-
-        const r1 = Bcs.getInstance().de_ent(Uint8Array.from(res!.results![0].returnValues![0][0]));
-        const a = Bcs.getInstance().de_entInfo(Uint8Array.from(r1.avatar));
-        var ret : EntityAnswer = {address:query.address, like:r1.like, dislike:r1.dislike, resource_object:r1.resource?.some ?? undefined,
-            details:{homepage:a.homepage, name:a.name, avatar:a.avatar, x:a.twitter, discord:a.discord, description:a.description}, 
-            }; 
-
-        if (r1.resource?.some && query.showTags) {
-            const res2 = await Protocol.Client().getObject({id:r1.resource?.some, options:{showContent:true, showPreviousTransaction:true, showType:true}});
-            ret.tags = (res2?.data?.content as any)?.fields?.tags?.map((v:any) => {
-                return {address:v.fields.object, nick:v.fields.nick, tags:v.fields.tags}
-            })
-            
-            ret.lastActive_digest = res2.data?.previousTransaction ?? '';
-        }
-
-        if (r1.resource?.some && query.showMarks) {
-            const fields = await Protocol.Client().getDynamicFields({parentId:r1.resource?.some});
-            if (fields.data.length > 0) {
-                const objects = await Protocol.Client().multiGetObjects({ids:fields.data.map(v => v.objectId), options:{showContent:true}});
-                ret.marks = objects.map((i:any) => {
-                    return {mark_name:i.data.content.fields.name, objects:i.data.content.fields.value}
-                })
-            }
-        }
-        return ret
-    }
-}