wowok_agent 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok_agent",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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/account.ts

@@ -240,6 +240,7 @@ export class Account {
 
         if (addr && b > BigInt(0)) {
             if (!token_type || token_type === '0x2::sui::SUI' || token_type === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
+                console.log(1)
                 return txb.splitCoins(txb.gas, [balance_required]);
             } else {
                 const r = await Protocol.Client().getCoins({owner: addr, coinType:token_type});

package/src/call/arbitration.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, IsValidArgType, } from 'wowok';
+import { TransactionBlock, IsValidArgType, Resource, ResourceObject, } from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Treasury, 
     Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, WitnessFill
 } from 'wowok';
@@ -118,11 +118,12 @@ export class CallArbitration extends CallBase {
             }
             if (!treasury_address || !IsValidAddress(treasury_address)) {
                 const d = (this.data?.fee_treasury as any)?.description ?? '';
-                withdraw_treasury = Treasury.New(txb, this.data?.type_parameter!, permission ?? permission_address, d, permission?undefined:passport);
+                withdraw_treasury = Treasury.New(txb, this.data?.type_parameter!, permission ? permission.get_object() : permission_address, 
+                    d, permission?undefined:passport);
             }
 
-            obj = Arbitration.New(txb, this.data.type_parameter!, permission ?? permission_address, this.data?.description??'', 
-                BigInt(this.data?.fee ?? 0), withdraw_treasury??treasury_address, permission?undefined:passport);
+            obj = Arbitration.New(txb, this.data.type_parameter!, permission ? permission.get_object() : permission_address, this.data?.description??'', 
+                BigInt(this.data?.fee ?? 0), withdraw_treasury? withdraw_treasury.get_object() : treasury_address, permission?undefined:passport);
         } else if (object_address) {
             if (IsValidAddress(object_address) && this.data.type_parameter && permission_address) {
                 obj = Arbitration.From(txb, this.data.type_parameter, permission_address, object_address)

package/src/call/base.ts

@@ -1,6 +1,6 @@
 
 
-import { Protocol, TransactionBlock, CallResponse, Guard, TransactionArgument, Entity, IsValidAddress, Resource, TxbObject, TransactionResult, TxbAddress, array_unique, TagName} from 'wowok';
+import { Protocol, TransactionBlock, CallResponse, Guard, TransactionArgument, Entity, IsValidAddress, Resource, TxbObject, TransactionResult, TxbAddress, array_unique, TagName, ResourceObject} from 'wowok';
 import { PassportObject, Errors, ERROR, Permission, 
     PermissionIndexType, GuardParser, Passport, WitnessFill
 } from 'wowok';
@@ -46,21 +46,9 @@ export function ResponseData(response: CallResponse | undefined) : ResponseData[
     return res;
 }
 
-export const mark_address = async (txb:TransactionBlock, mark:AddressMark, account?:string) => {
-    const addr = Account.Instance().get_address(account);
-    if (addr) {
-        const r = await queryTableItem_Personal({address:addr}); //@ use cache
-        const resource = r?.mark_object ? Resource.From(txb, r.mark_object) : Resource.From(txb, Entity.From(txb).create_resource2());
-        resource.add(mark.address, mark.tags, mark.name);
-        if (!r?.mark_object) {
-            resource.launch(); // launch new
-        }
-    } else {
-        ERROR(Errors.InvalidParam, 'account - ' + account)
-    }
-}
 export class CallBase {
     // operation implementation for a call
+    resouceObject:ResourceObject | undefined;
     protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {};
     constructor () {}
     // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call; 
@@ -70,22 +58,16 @@ export class CallBase {
     async call_with_witness (param: CallWithWitnessParam) : Promise<CallResponse | undefined> {
         if (param.info.guard.length > 0) {         // prepare passport
             const p: GuardParser | undefined = await GuardParser.Create([...param.info.guard]);
-            const pair = Account.Instance().get_pair(param.account, true);
-            if (!pair) ERROR(Errors.Fail, 'account invalid')
 
             if (p) {
                 const query = await p.done(param.info.witness);
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
-                    this.operate(new TransactionBlock(), passport?.get_object(), param?.account)
+                    await this.operate(new TransactionBlock(), passport?.get_object(), param?.account)
                     passport.destroy();
-
-                    return await Protocol.Client().signAndExecuteTransaction({
-                        transaction: txb, 
-                        signer: pair!,
-                        options:{showObjectChanges:true},
-                    });
+                    
+                    return await this.sign_and_commit(txb, param.account);
                 }
             } else {
                 ERROR(Errors.Fail, 'guard finish_passport')
@@ -96,11 +78,12 @@ export class CallBase {
     protected async check_permission_and_call (permission:string, permIndex: PermissionIndexType[], guards_needed: string[],
         checkOwner?:boolean, checkAdmin?:boolean, account?:string) : Promise<CallResult>  {
         var guards : string[] = [];
-        const pair = Account.Instance().get_pair(account, true);
-        if (!pair) ERROR(Errors.Fail, 'account invalid')
 
         if (permIndex.length > 0 || checkOwner) {
-            const p = await query_permission({permission_object:permission, address:pair!.toSuiAddress()});
+            const addr = Account.Instance().get_address(account);
+            if (!addr) ERROR(Errors.InvalidParam, 'check_permission_and_call: account invalid');
+
+            const p = await query_permission({permission_object:permission, address:addr!});
             if (checkOwner && !p.owner) ERROR(Errors.noPermission, 'owner');
             if (checkAdmin && !p.admin) ERROR(Errors.noPermission, 'admin');
 
@@ -125,14 +108,10 @@ export class CallBase {
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
-                    this.operate(new TransactionBlock(), passport?.get_object(), account)
+                    await this.operate(new TransactionBlock(), passport?.get_object(), account)
                     passport.destroy();
-
-                    return await Protocol.Client().signAndExecuteTransaction({
-                        transaction: txb, 
-                        signer: pair!,
-                        options:{showObjectChanges:true},
-                    });
+                    
+                    return await this.sign_and_commit(txb, account);
                 }
             } 
             
@@ -142,20 +121,48 @@ export class CallBase {
         }
     }
     protected async exec (account?:string) : Promise<CallResponse> {
+        const txb = new TransactionBlock();
+        await this.operate(txb, undefined, account);
+        return await this.sign_and_commit(txb, account);
+    }
+
+    protected async new_with_mark(txb:TransactionBlock, object:TxbAddress, named_new?:Namedbject, account?:string, innerTags:string[]=[TagName.Launch]) {
+        const tags = named_new?.tags ? array_unique([...named_new.tags, ...innerTags]) : array_unique([...innerTags]);
+
+        if (!this.resouceObject) {
+            const addr = Account.Instance().get_address(account);
+            if (addr) {
+                const r = await queryTableItem_Personal({address:addr}); //@ use cache
+                if (!r?.mark_object) {
+                    this.resouceObject = Entity.From(txb).create_resource2(); // new 
+                } else {
+                    Resource.From(txb, r.mark_object).add(object, tags, named_new?.name);
+                    return
+                }
+            } else {
+                ERROR(Errors.InvalidParam, 'account - ' + account)
+            }
+        }
+        if (this.resouceObject) {
+            Resource.From(txb, this.resouceObject).add(object, tags, named_new?.name);
+        } else {
+            ERROR(Errors.Fail, 'invalid personal mark')
+        }
+    }
+
+    protected async sign_and_commit(txb: TransactionBlock, account?: string) : Promise<CallResponse> {
         const pair = Account.Instance().get_pair(account, true);
         if (!pair) ERROR(Errors.Fail, 'account invalid')
 
-        const txb = new TransactionBlock();
-        this.operate(txb, undefined, account);
+        if (this.resouceObject) {
+            Resource.From(txb, this.resouceObject).launch(); //@ resource launch, if created.
+            this.resouceObject = undefined;
+        }
+    
         return await Protocol.Client().signAndExecuteTransaction({
             transaction: txb, 
             signer: pair!,
             options:{showObjectChanges:true},
         });
     }
-
-    protected new_with_mark(txb:TransactionBlock, object:TxbAddress, named_new?:Namedbject, account?:string, innerTags:string[]=[TagName.Launch]) {
-        const tags = named_new?.tags ? array_unique([...named_new.tags, ...innerTags]) : array_unique([...innerTags]);
-        mark_address(txb, {address:object, name:named_new?.name, tags:tags}, account)
-    }
 }

package/src/call/demand.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, IsValidArgType, IsValidCoinType } from 'wowok';
+import { TransactionBlock, IsValidArgType, IsValidCoinType, Resource, ResourceObject } from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, 
     PermissionIndexType, Demand, } from 'wowok';
 import { query_objects, ObjectDemand } from '../objects';

package/src/call/entity_permission.ts

@@ -1,5 +1,5 @@
 import { CallBase, CallResult, Namedbject } from "./base";
-import { TransactionBlock, CallResponse} from 'wowok';
+import { TransactionBlock, CallResponse, Resource, ResourceObject} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, UserDefinedIndex,
     PermissionIndexType, WitnessFill
 } from 'wowok';

package/src/call/guard.ts

@@ -5,7 +5,10 @@
 
 import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, 
     concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead, CallResponse, 
-    IsValidDesription} from "wowok";
+    IsValidDesription,
+    Resource,
+    ResourceObject,
+    PassportObject} from "wowok";
 import { Account } from "../account";
 import { CallBase, CallResult, Namedbject } from "./base";
 
@@ -32,7 +35,7 @@ export type GuardNode = { identifier: number; } // Data from GuardConst
 export interface CallGuard_Data {
     namedNew?: Namedbject;
     description: string;
-    table: GuardConst[]; //  data used by multiple logical guard nodes
+    table?: GuardConst[]; //  data used by multiple logical guard nodes
     root: GuardNode; // root must return ValueType.TYPE_BOOL     
 }
 export class CallGuard extends CallBase {
@@ -42,6 +45,10 @@ export class CallGuard extends CallBase {
         this.data = data;
     }
     async call(account?:string) : Promise<CallResult> {
+        return await this.exec(account)
+    }
+    
+    protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {
         if (!this.data?.root) {
             ERROR(Errors.InvalidParam, 'guard root node invalid')
         }
@@ -50,26 +57,25 @@ export class CallGuard extends CallBase {
         }
     
         // check const
-        this.data.table.forEach(v => {
+        this.data?.table?.forEach(v => {
             if (!IsValidU8(v.identifier) || v.identifier < 1) ERROR(Errors.InvalidParam, 'table.identifer invalid');
             if (!v.bWitness && v.value === undefined) ERROR(Errors.InvalidParam, 'table.value');
         })
     
-        if (hasDuplicates(this.data.table.map(v => v.identifier))) {
+        if (this.data?.table && hasDuplicates(this.data?.table?.map(v => v.identifier))) {
             ERROR(Errors.InvalidParam, 'table.identifer duplicates')
         }
     
         // check root
         var output : Uint8Array[]= [];
-        buildNode(this.data.root!, ValueType.TYPE_BOOL, this.data.table, output);
+        buildNode(this.data.root!, ValueType.TYPE_BOOL, this.data?.table ?? [], output);
         const bytes = (concatenate(Uint8Array, ...output) as Uint8Array); 
-        const txb = new TransactionBlock();
     
         const obj = txb.moveCall({
             target: Protocol.Instance().guardFn('new') as FnCallType,
             arguments: [txb.pure.string(this.data.description), txb.pure.vector('u8', [].slice.call(bytes.reverse()))],  
         });
-        this.data.table.forEach((v) => {
+        this.data?.table?.forEach((v) => {
             if (v.bWitness) {
                 const n = new Uint8Array(1); n.set([v.value_type], 0);
                 txb.moveCall({
@@ -90,15 +96,6 @@ export class CallGuard extends CallBase {
             arguments:[txb.object(obj)]
         });
         this.new_with_mark(txb, addr, this.data?.namedNew, account);
-
-        const pair = Account.Instance().get_pair(account, true);
-        if (!pair) ERROR(Errors.Fail, 'account invalid')
-    
-        return await Protocol.Client().signAndExecuteTransaction({
-            transaction: txb, 
-            signer: pair!,
-            options:{showObjectChanges:true},
-        });
     }
 }
 

package/src/call/machine.ts

@@ -1,6 +1,8 @@
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, TransactionBlock,
     PermissionIndexType, Machine, Machine_Forward, Machine_Node,  Deliverable, ParentProgress, Progress, ProgressNext,
     TxbAddress,
+    Resource,
+    ResourceObject,
 } from 'wowok';
 import { CallBase, CallResult, Namedbject } from "./base";
 import { Account } from '../account';
@@ -112,7 +114,7 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
                 const d = (this.data?.permission as any)?.description ?? '';
                 permission = Permission.New(txb, d);
             }
-            obj = Machine.New(txb, permission ?? permission_address, this.data?.description??'', this.data?.endpoint ?? '', permission?undefined:passport);
+            obj = Machine.New(txb, permission ? permission.get_object() : permission_address, this.data?.description??'', this.data?.endpoint ?? '', permission?undefined:passport);
         } else {
             if (IsValidAddress(object_address) &&permission_address && IsValidAddress(permission_address)) {
                 obj = Machine.From(txb, permission_address, object_address)

package/src/call/personal.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock } from 'wowok';
+import { ResourceObject, TransactionBlock } from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Entity, Entity_Info, TagName, Resource} from 'wowok';
 import { CallBase, CallResult, Namedbject } from "./base";
 

package/src/call/repository.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, CallResponse} from 'wowok';
+import { TransactionBlock, CallResponse, Resource, ResourceObject} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Repository,
     Repository_Policy, Repository_Policy_Data, Repository_Policy_Data2, Repository_Policy_Data_Remove,
     Repository_Policy_Mode, WitnessFill
@@ -59,7 +59,7 @@ export class CallRepository extends CallBase {
                 permission = Permission.New(txb, d);
             }
             
-            obj = Repository.New(txb, permission ?? permission_address, this.data?.description??'', this.data?.mode, permission?undefined:passport)
+            obj = Repository.New(txb, permission ? permission.get_object() : permission_address, this.data?.description??'', this.data?.mode, permission?undefined:passport)
         } else {
             if (IsValidAddress(object_address) && this.data.permission && IsValidAddress(permission_address)) {
                 obj = Repository.From(txb, permission_address, object_address)
@@ -70,9 +70,6 @@ export class CallRepository extends CallBase {
             if (this.data?.description !== undefined && object_address) {
                 obj?.set_description(this.data.description, passport);
             }
-            if (this.data?.mode !== undefined && object_address) { //@ priority??
-                obj?.set_policy_mode(this.data.mode, passport)
-            }
             if (this.data?.reference !== undefined) {
                 switch (this.data.reference.op) {
                     case 'set':
@@ -126,6 +123,9 @@ export class CallRepository extends CallBase {
                         break;
                 }
             }
+            if (this.data?.mode !== undefined && object_address) { //@ priority??
+                obj?.set_policy_mode(this.data.mode, passport)
+            }
             if (permission) {
                 this.new_with_mark(txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);
             }

package/src/call/service.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, CallResponse, IsValidArgType, TxbAddress, TagName} from 'wowok';
+import { TransactionBlock, CallResponse, IsValidArgType, TxbAddress, TagName, Resource, ResourceObject} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex,
     PermissionIndexType,  BuyRequiredEnum, Customer_RequiredInfo, DicountDispatch, Service, Service_Buy, 
     Service_Guard_Percent, Service_Sale, WithdrawPayee, Treasury, WitnessFill
@@ -95,7 +95,7 @@ export class CallService extends CallBase {
             if (this.data?.machine !== undefined) {
                 perms.push(PermissionIndex.service_machine)
             }
-            if (this.data?.payee_treasury !== undefined && object_address) {
+            if (treasury_address !== undefined && object_address) {
                 perms.push(PermissionIndex.service_payee)
             }
             if (this.data?.withdraw_guard !== undefined) {
@@ -161,7 +161,8 @@ export class CallService extends CallBase {
                 const d = (this.data?.payee_treasury as any)?.description ?? '';
                 payee = Treasury.New(txb, this.data?.type_parameter!, permission ?? permission_address, d, permission?undefined:passport);
             }
-            obj = Service.New(txb, this.data.type_parameter!, permission??permission_address, this.data?.description??'', payee??treasury_address, permission?undefined:passport)
+            obj = Service.New(txb, this.data.type_parameter!, permission?permission.get_object():permission_address, 
+                this.data?.description??'', payee?payee.get_object():treasury_address, permission?undefined:passport)
         } else {
             if (IsValidAddress(object_address) && this.data.type_parameter && permission_address && IsValidAddress(permission_address)) {
                 obj = Service.From(txb, this.data.type_parameter, permission_address, object_address)

package/src/call/treasury.ts

@@ -1,4 +1,4 @@
-import { TransactionBlock, CallResponse, IsValidArgType} from 'wowok';
+import { TransactionBlock, CallResponse, IsValidArgType, Resource, ResourceObject} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex,
     PermissionIndexType, DepositParam, Treasury, Treasury_WithdrawMode, WithdrawParam, WitnessFill
 } from 'wowok';
@@ -96,7 +96,6 @@ export class CallTreasury extends CallBase {
             } else {
                 perms.push(PermissionIndex.treasury_withdraw)
             }
-
             return await this.check_permission_and_call(permission_address, perms, guards, checkOwner, undefined, account)
         }
         return await this.exec(account);
@@ -111,7 +110,7 @@ export class CallTreasury extends CallBase {
                 const d = (this.data?.permission as any)?.description ?? '';
                 permission = Permission.New(txb, d);
             }
-            obj = Treasury.New(txb, this.data.type_parameter!, permission ?? permission_address, this.data?.description??'', permission?undefined:passport)
+            obj = Treasury.New(txb, this.data.type_parameter!, permission ? permission.get_object() : permission_address, this.data?.description??'', permission?undefined:passport)
         } else {
             if (IsValidAddress(object_address) && this.data.type_parameter && permission_address && IsValidAddress(permission_address)) {
                 obj = Treasury.From(txb, this.data.type_parameter, permission_address, object_address)
@@ -162,11 +161,11 @@ export class CallTreasury extends CallBase {
                 }
             }
             if (permission) {
-                this.new_with_mark(txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);
+                await this.new_with_mark(txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);
             }
 
             if (!object_address) {
-                this.new_with_mark(txb, obj.launch(), (this.data?.object as any)?.namedNew, account);
+                await this.new_with_mark(txb, obj.launch(), (this.data?.object as any)?.namedNew, account);
             } 
         }
     }

package/src/call.ts

@@ -1,8 +1,7 @@
 
 /**
  * Provide a this interface for AI
- * Operation sequence Priority: common operation > Guard change > permission change
- * Recommended: Changes to guard and permission are committed on-chain separately to avoid permission dependencies for other operations.
+ * Restrictive prioritization, such as setting a deposit first and setting a deposit guard later (only subsequent deposits are affected).
  */
 
 import { CallArbitration, CallArbitration_Data } from "./call/arbitration";

package/src/objects.ts

@@ -12,8 +12,8 @@ import {WowokCache, OBJECT_KEY, CacheExpire, CacheName, CachedData} from './cach
 
 export interface ObjectBase {
     object: string;
-    type?: string | 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' |
-        'Personal' | 'Permission' | 'Mark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
+    type?: string |  'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' | 'Discount' |
+        'Personal' | 'EntityPermission' | 'PersonalMark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
         'TableItem_DemandPresenter' | 'TableItem_MachineNode' | 'TableItem_ServiceSale' | 'TableItem_TreasuryHistory' | 'TableItem_ArbVote' |
         'TableItem_RepositoryData' | 'TableItem_PersonalMark';
     type_raw?: string;
@@ -230,7 +230,7 @@ export interface ObjectMark extends ObjectBase {
     tag_count: number;
 }
 
-export interface TableItem_MarkTag extends ObjectBase, Tags {
+export interface TableItem_PersonalMark extends ObjectBase, Tags {
 }
 
 export enum CacheType {
@@ -298,10 +298,10 @@ export const query_table_json = async (json:string) : Promise<string> => {
 }
 
 // query personal information; json: ObjectsAnswer; return ObjectPersonal | undefined .
-export const query_personal = async (json:string) : Promise<string> => {
+export const query_personal_json = async (json:string) : Promise<string> => {
     try {
         const q : PersonalQuery = JSON.parse(json);
-        return JSON.stringify({data:(await queryTableItem_Personal(q)) ?? ''});
+        return JSON.stringify({data:(await queryTableItem_Personal(q) ?? '')});
     } catch (e) {
         return JSON.stringify({error:e?.toString()})
     }
@@ -362,35 +362,34 @@ export const queryTableItem_Personal = async (query:PersonalQuery) : Promise<Obj
     if (!IsValidAddress(query.address))  ERROR(Errors.IsValidAddress, 'entity.address')
     const time = new Date().getTime();
     const cache = WowokCache.Instance().get(CacheName.personal);
+
     if (cache && !query.no_cache) {
         try {
             let data = cache.load(OBJECT_KEY(query.address, CacheName.personal))
             
             if (data) {
                 const r:CachedData = JSON.parse(data);
-
                 if (r?.expire === 'INFINITE' || r.expire <= time) { 
-                    const d = data2object(JSON.parse(r.data));
-                    d.cache_expire = r.expire;    
-                    return d as ObjectPersonal;                         
+                    const d = JSON.parse(r.data) as ObjectPersonal;
+                    d.cache_expire = r.expire;  
+                    return d;                         
                 }
             }                 
         } catch (e) {
             console.log(e)
         }
     } 
-    const res = await Protocol.Client().getDynamicFieldObject({parentId:Protocol.Instance().objectEntity(), name:{type:'address', value:query.address}});
-    if (res?.data) {
-        const ret = data2object(res?.data) as ObjectPersonal;
+    const res = await tableItem(tableItemQuery_byAddress(Protocol.Instance().objectEntity(), query.address));
+    if (res.type === 'Personal') {
         if (cache) {
             try {
                 const expire = cache.expire_time()+((new Date()).getTime()); // guard & payment immutable
-                const r:CachedData = {expire:expire, data:JSON.stringify(res.data)}
+                const r:CachedData = {expire:expire, data:JSON.stringify(res)}
                 cache.save(OBJECT_KEY(query.address, CacheName.personal), JSON.stringify(r));
-                ret.cache_expire = expire;
+                res.cache_expire = expire;
             } catch(e) { console.log(e)}               
         }
-        return ret
+        return res as ObjectPersonal;
     }
 }
 
@@ -468,7 +467,7 @@ export function data2object(data?:any) : ObjectBase {
     if (type) {
         switch(type) {
         case 'Permission':
-            return {object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+            return {object:id, type:'EntityPermission', type_raw:type_raw, owner:owner, version:version,
                 builder: content?.builder ??'', admin:content?.admin, description:content?.description??'',
                 entity_count: parseInt(content?.table?.fields?.size), 
                 biz_permission:content?.user_define?.fields?.contents?.map((v:any) => {
@@ -605,7 +604,7 @@ export function data2object(data?:any) : ObjectBase {
             } as ObjectGuard;  
         case 'Resource' :
             return {
-                object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                object:id, type:'PersonalMark', type_raw:type_raw, owner:owner, version:version,
                 tag_count:parseInt(content?.tags?.fields?.size)
             } as ObjectMark;   
         }
@@ -617,35 +616,35 @@ export function data2object(data?:any) : ObjectBase {
         if(end && Protocol.Instance().hasPackage(end)) {
             if (end.includes('::demand::Tips>')) {
                 return {
-                    object:id, type:'DemandTable_Presenter', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_DemandPresenter', type_raw:type_raw, owner:owner, version:version,
                     service:content?.name, presenter:content?.value?.fields?.who, recommendation:content?.value?.fields?.tips
                 } as TableItem_DemandPresenter;
             } else if (end.includes('::machine::NodePair>>>')) {
                 return {
-                    object:id, type:'MachineTable_Node', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_MachineNode', type_raw:type_raw, owner:owner, version:version,
                     node:{name:content?.name, pairs:Machine.rpc_de_pair(content?.value)}
                 } as TableItem_MachineNode;
             } else if (end.includes('::progress::History>')) {
                 return {
-                    object:id, type:'ProgressTable_History', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_ProgressHistory', type_raw:type_raw, owner:owner, version:version,
                     history:Progress.DeHistory(content)
                 } as TableItem_ProgressHistory;
             } else if (end.includes('::service::Sale>')) {
                 return {
-                    object:id, type:'ServiceTable_Sale', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_ServiceSale', 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 TableItem_ServiceSale;
             } else if (end.includes('::treasury::Record>')) {
                 return {
-                    object:id, type:'TreasuryTable_History', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_TreasuryHistory', 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 TableItem_TreasuryHistory;
             } else if (end.includes('::arb::Voted>')) {
                 return {
-                    object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                    object:id, type:'TableItem_ArbVote', 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 TableItem_ArbVote;
@@ -664,16 +663,16 @@ export function data2object(data?:any) : ObjectBase {
             } 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,
+                    object:id, type:'Personal', type_raw:type_raw, owner:owner, version:version,
                     address:content?.name, like:content?.value?.fields?.like, dislike:content?.value?.fields?.dislike, 
                     mark_object: content?.value?.fields?.resource, lastActive_digest: data?.previousTransaction, 
                     info : {homepage:info?.homepage, name:info?.name, avatar:info?.avatar, twitter:info?.twitter, discord:info?.discord, 
                     description:info?.description}
                 } as ObjectPersonal;
             } else if (end.includes('::resource::Tags>')) {
-                return {object:id, type:'TableItem_MarkTag', type_raw:type_raw, owner:owner, version:version,
+                return {object:id, type:'TableItem_PersonalMark', type_raw:type_raw, owner:owner, version:version,
                     address:content?.name, name:content?.value?.fields?.nick, tags:content?.value?.fields?.tags
-                } as TableItem_MarkTag;
+                } as TableItem_PersonalMark;
             }
         }
     }