wowok_agent 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok_agent",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey } from 'wowok';
+import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey, Protocol, CoinBalance, CoinStruct, TransactionResult, TransactionBlock, TransactionArgument, ERROR, Errors } from 'wowok';
 import { getFaucetHost, requestSuiFromFaucetV0, requestSuiFromFaucetV1 } from 'wowok';
 export interface AccountData {
     name: string; 
@@ -217,4 +217,67 @@ export class Account {
             })
         }
     }
-}
+
+    // token_type is 0x2::sui::SUI, if not specified.
+    balance = async (name?:string, token_type?:string) : Promise<CoinBalance | undefined> => {
+        const addr = this.get_address(name);
+        if (addr) {
+            return await Protocol.Client().getBalance({owner: addr, coinType:token_type});
+        }
+    }
+
+    // token_type is 0x2::sui::SUI, if not specified.
+    coin = async (name?:string, token_type?:string) : Promise<CoinStruct[] | undefined> => {
+        const addr = this.get_address(name);
+        if (addr) {
+            return (await Protocol.Client().getCoins({owner: addr, coinType:token_type})).data;
+        }
+    }
+
+    get_coin_object = async (txb: TransactionBlock, balance_required:string | bigint | number, name?:string, token_type?:string) : Promise<TransactionResult | undefined> => {
+        const addr = this.get_address(name);
+        const b = BigInt(balance_required);
+
+        if (addr && b > BigInt(0)) {
+            if (!token_type || token_type === '0x2::sui::SUI' || token_type === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
+                return txb.splitCoins(txb.gas, [balance_required]);
+            } else {
+                const r = await Protocol.Client().getCoins({owner: addr, coinType:token_type});
+                const objects : string[] = []; var current = BigInt(0);
+                for (let i = 0; i < r.data.length; ++ i) {
+                    current += BigInt(r.data[i].balance);
+                    objects.push(r.data[i].coinObjectId);
+                    if (current >= b) {
+                        break;
+                    }
+                }
+
+                if (objects.length === 1) {
+                    return txb.splitCoins(objects[0], [b]);
+                } else {
+                    const ret = objects.pop()!;
+                    txb.mergeCoins(ret, objects);
+                    return txb.splitCoins(ret, [b])
+                }
+            }
+        }
+    }
+    coin_with_balance = async(balance_required:string | bigint | number, account?:string, token_type?:string) : Promise<string | undefined> => {
+        const pair = this.get_pair(account, true);
+        if (!pair) ERROR(Errors.Fail, 'account invalid')
+    
+        const txb = new TransactionBlock();
+        const res = await Account.Instance().get_coin_object(txb, balance_required, account, token_type);
+        if (res) {
+            txb.transferObjects([(res as unknown) as TransactionArgument], pair?.toSuiAddress()!)
+            const r = await Protocol.Client().signAndExecuteTransaction({
+                transaction: txb, 
+                signer: pair!,
+                options:{showObjectChanges:true},
+            });
+            const t = token_type ?? '0x2::sui::SUI';
+            return ((r as any)?.objectChanges.find((v:any) => v?.type === 'created' && (v?.objectType as string).includes(t)) as any)?.objectId;
+        }
+    }
+}
+

package/src/cache.ts

@@ -1,27 +1,52 @@
 
 import { Protocol } from "wowok";
 
+export type CacheExpire = number | 'INFINITE';
+
+export interface CachedData {
+    expire: number | 'INFINITE';
+    data: string | any; 
+}
+
 export abstract class CacheData {
     constructor(expire: number) { this.expire = expire; } // 10m default
     abstract load(key: string) : string | null | undefined;
     abstract save(key: string, data:string) : void;
+    abstract remove(key: string) : void;
     expire_time() {return this.expire};
     protected expire;
 }
 
-export const OBJECT_KEY = (object: string) : string => {
-    return object + Protocol.Instance().package('wowok_origin') + 'V2';
+export enum CacheName {
+    object = 'OBJECT',
+    resource = 'RESOURCE',
+}
+
+export const OBJECT_KEY = (object_address: string) : string => {
+    return object_address + Protocol.Instance().package('wowok_origin') + CacheName.object + '-V2';
+}
+export const PERSONAL_RESOURCE_KEY = (person_address: string) : string => {
+    return person_address + Protocol.Instance().package('wowok_origin') + CacheName.resource + '-V2';
+}
+
+export interface PersonalResouceCache {
+    address: string;
+    resource: string;
+    time_expire?: CacheExpire;
 }
 
 export class MemeryCache extends CacheData {
     constructor(expire: number = 10000) {super(expire)}
-    protected data = new Map<string, string>;
+    protected data = new Map<string, string>();
     load(key: string) : string | null | undefined {
         return this.data.get(key)
     }
     save(key: string, data:string) : void {
         this.data.set(key, data);
     }
+    remove(key: string) : void {
+        this.data.delete(key)
+    }
 }
 
 export class LocalStorageCache extends CacheData {
@@ -32,11 +57,14 @@ export class LocalStorageCache extends CacheData {
     save(key: string, data:string) : void {
         return localStorage.setItem(key, data)
     }
+    remove(key: string) : void {
+        return localStorage.removeItem(key)
+    }
 }
 
 export class WowokCache {
     static _instance: any;
-    private cache: any;
+    private cache: Map<string, CacheData | undefined> = new Map();
     
     constructor() {}
     static Instance() : WowokCache {
@@ -45,10 +73,11 @@ export class WowokCache {
         }; return WowokCache._instance
     }
 
-    set(cache:CacheData) {
-        this.cache = cache;
+    set(name:string | CacheName, cache:CacheData | undefined) {
+        this.cache.set(name, cache);
     }
-    get() : CacheData {
-        return this.cache;
+
+    get(name:string | CacheName) : CacheData | undefined {
+        return this.cache.get(name);
     }
 }

package/src/call/arbitration.ts

@@ -1,14 +1,14 @@
-import { TransactionBlock, CallResponse, IsValidArgType} from 'wowok';
+import { TransactionBlock, CallResponse, IsValidArgType, TransactionResult} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Treasury, 
     Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, WitnessFill
 } from 'wowok';
 import { query_objects, ObjectArbitration, } from '../objects';
-import { CallBase, CallResult } from "./base";
+import { CallBase, CallResult, AddressMark } from "./base";
 
 export interface CallArbitration_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
-    
+    mark?:AddressMark;
     type_parameter?: string;
     permission_new?: string;
     description?: string;
@@ -100,9 +100,9 @@ export class CallArbitration extends CallBase {
 
             return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
-    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+    protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Arbitration | undefined ; let permission: any; let withdraw_treasury:any;
         if (!this.data.object) {
             if (!this.data?.permission || !IsValidAddress(this.data?.permission)) {
@@ -177,8 +177,15 @@ export class CallArbitration extends CallBase {
             if (permission) {
                 permission.launch();
             }
+            var mark : TransactionResult | string | undefined ;
             if (!this.data.object) {
-                obj?.launch();
+                mark = obj?.launch();
+            } else {
+                mark = this.data.object;
+            }
+
+            if (this.data?.mark !== undefined) {
+                this.mark(txb, mark, this.data?.mark, account)
             }
         }
     }

package/src/call/base.ts

@@ -1,18 +1,22 @@
 
 
-import { Protocol, TransactionBlock, CallResponse, Guard} from 'wowok';
+import { Protocol, TransactionBlock, CallResponse, Guard, TransactionArgument, Entity, IsValidAddress, Resource, TxbObject, TransactionResult} from 'wowok';
 import { PassportObject, Errors, ERROR, Permission, 
     PermissionIndexType, GuardParser, Passport, WitnessFill
 } from 'wowok';
 import { query_permission } from '../permission';
 import { Account } from '../account';
-import { ObjectBase } from '../objects';
-
+import { ObjectBase} from '../objects';
+import { query_entity } from '../entity';
 
+export interface AddressMark {
+    nick_name?:string; 
+    tags:string[]; 
+    groups:string[];
+}
 export interface ResponseData extends ObjectBase {
     change:'created' | 'mutated' | string;
 } 
-
 export interface GuardInfo_forCall {
     guard: string[];
     witness: WitnessFill[];
@@ -39,7 +43,7 @@ export function ResponseData(response: CallResponse | undefined ) : ResponseData
 }
 export class CallBase {
     // operation implementation for a call
-    protected async operate(txb:TransactionBlock, passport?:PassportObject) {};
+    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; 
     // return ResponseData when the call has completed; 
@@ -56,7 +60,7 @@ export class CallBase {
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
-                    this.operate(new TransactionBlock(), passport?.get_object())
+                    this.operate(new TransactionBlock(), passport?.get_object(), param?.account)
                     passport.destroy();
 
                     return await Protocol.Client().signAndExecuteTransaction({
@@ -103,7 +107,7 @@ export class CallBase {
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
-                    this.operate(new TransactionBlock(), passport?.get_object())
+                    this.operate(new TransactionBlock(), passport?.get_object(), account)
                     passport.destroy();
 
                     return await Protocol.Client().signAndExecuteTransaction({
@@ -116,7 +120,7 @@ export class CallBase {
             
             return {guard:[...guards], witness:p!.future_fills()};
         } else { // no passport needed
-            return this.exec()
+            return await this.exec()
         }
     }
     protected async exec (account?:string) : Promise<CallResponse> {
@@ -124,11 +128,27 @@ export class CallBase {
         if (!pair) ERROR(Errors.Fail, 'account invalid')
 
         const txb = new TransactionBlock();
-        this.operate(txb);
+        this.operate(txb, undefined, account);
         return await Protocol.Client().signAndExecuteTransaction({
             transaction: txb, 
             signer: pair!,
             options:{showObjectChanges:true},
         });
     }
+
+    protected mark = async (txb:TransactionBlock, object: string | TransactionResult, mark:AddressMark, account?:string) => {
+        const addr = Account.Instance().get_address(account);
+        if (addr) {
+            const r = await query_entity(addr);
+            if (r?.resource) {
+                const resource = Resource.From(txb, r.resource);
+                resource.add_tags(object, mark.nick_name??'', mark.tags);
+                if (mark.groups.length > 0) {
+                    resource.add2(object, mark.groups);
+                }
+            }
+        } else {
+            ERROR(Errors.InvalidParam, 'account - ' + account)
+        }
+    }
 }

package/src/call/demand.ts

@@ -1,19 +1,18 @@
-import { TransactionBlock, CallResponse, IsValidArgType} from 'wowok';
-import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, PermissionIndex, UserDefinedIndex,
-    PermissionIndexType, Demand,  WitnessFill
-} from 'wowok';
+import { TransactionBlock, IsValidArgType, IsValidCoinType } from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, 
+    PermissionIndexType, Demand, } from 'wowok';
 import { query_objects, ObjectDemand } from '../objects';
 import { CallBase, CallResult } from "./base";
+import { Account } from '../account';
 
 export interface CallDemand_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
-    permission_new?: string;
     type_parameter?: string;
     guard?: {address:string; service_id_in_guard?:number};
     description?: string;
     time_expire?: {op: 'duration'; minutes:number} | {op:'set'; time:number};
-    bounty?: {op:'add'; object?:string; balance:string} | {op:'refund'} | {op:'reward'; service:string};
+    bounty?: {op:'add'; object:{address:string}|{balance:string|number}} | {op:'refund'} | {op:'reward'; service:string};
     present?: {service: string | number; recommend_words:string; service_pay_type:string, guard?:string | 'fetch'}; // guard is the present guard of Demand
     reward?: string; // rerward the service
     refund?: boolean;
@@ -36,9 +35,6 @@ export class CallDemand extends CallBase {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.demand)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.demand_description)
             }
@@ -75,9 +71,9 @@ export class CallDemand extends CallBase {
             }
             return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
-    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+    protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Demand | undefined ; let permission: any;
 
         if (!this.data.object) {
@@ -109,16 +105,14 @@ export class CallDemand extends CallBase {
             }
             if (this.data?.bounty !== undefined) {
                 if (this.data.bounty.op === 'add') {
-                    let deposit : any | undefined; let b = BigInt(this.data.bounty.balance);
-                    if (b > BigInt(0)) {
-                        if (this.data.type_parameter === '0x2::sui::SUI' || this.data.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
-                            deposit = txb.splitCoins(txb.gas, [b])[0];
-                        } else if (this.data?.bounty?.object) {
-                            deposit = txb.splitCoins(this.data.bounty.object, [b])[0];
-                        }
-                        if (deposit) {
-                            obj?.deposit(deposit);                              
+                    if (IsValidAddress((this.data.bounty.object as any)?.address)) {
+                        obj.deposit((this.data.bounty.object as any)?.address)
+                    } else if ((this.data.bounty.object as any)?.balance !== undefined){
+                        if (!IsValidCoinType(this.data.type_parameter)) {
+                            ERROR(Errors.IsValidCoinType, 'demand bounty')
                         }
+                        const r = await Account.Instance().get_coin_object(txb, (this.data.bounty.object as any)?.balance, account, this.data.type_parameter);
+                        if (r) obj.deposit(r)
                     }
                 } else if (this.data.bounty.op === 'refund') {
                     obj?.refund(passport);
@@ -133,9 +127,6 @@ export class CallDemand extends CallBase {
             if (this.data?.guard !== undefined) {
                 obj?.set_guard(this.data.guard.address, this.data.guard?.service_id_in_guard ?? undefined, passport)
             }
-            if (this.data?.permission_new !== undefined ) {
-                obj?.change_permission(this.data.permission_new);
-            }
             if (permission) {
                 permission.launch();
             }

package/src/call/{permission.ts → entity_permission.ts}

@@ -4,19 +4,19 @@ import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_E
     PermissionIndexType, WitnessFill
 } from 'wowok';
 
-export interface CallPermission_Data {
+export interface CallEntityPermission_Data {
     object?: string; // undefined for creating a new object
     builder?: string;
     admin?: {op:'add' | 'remove' | 'set', admins:string[]};
     description?: string;
-    entity?: {op:'add entity'; entities:Permission_Entity[]} | {op:'add permission'; permissions:Permission_Index[]} 
+    permission?: {op:'add entity'; entities:Permission_Entity[]} | {op:'add permission'; permissions:Permission_Index[]} 
         | {op:'remove entity'; addresses:string[]} | {op:'remove permission'; address:string; index:PermissionIndexType[]} 
         | {op:'transfer permission', from_address: string; to_address: string};
     biz_permission?: {op:'add'; data: UserDefinedIndex[]} | {op:'remove'; permissions: PermissionIndexType[]};
 }
-export class CallPermission extends CallBase {
-    data: CallPermission_Data;
-    constructor(data:CallPermission_Data) {
+export class CallEntityPermission extends CallBase {
+    data: CallEntityPermission_Data;
+    constructor(data:CallEntityPermission_Data) {
         super();
         this.data = data;
     }
@@ -27,7 +27,7 @@ export class CallPermission extends CallBase {
             if (this.data?.builder !== undefined || this.data?.admin !== undefined) {
                 checkOwner = true;
             }
-            if (this.data?.entity !== undefined || this.data?.biz_permission !== undefined) {
+            if (this.data?.permission !== undefined || this.data?.biz_permission !== undefined) {
                 checkAdmin = true;
             }
             if (this.data?.description !== undefined) {
@@ -35,7 +35,7 @@ export class CallPermission extends CallBase {
             }
             return await this.check_permission_and_call(this.data.object, [], [], checkOwner, checkAdmin, account)
         }
-        return this.exec(account)
+        return await this.exec(account)
     }
     protected async operate (txb:TransactionBlock, passport?:PassportObject) {
         let obj : Permission | undefined ; 
@@ -62,42 +62,43 @@ export class CallPermission extends CallBase {
                         break
                 }
             }
+            if (this.data?.biz_permission !== undefined) { // High priority operate
+                switch(this.data.biz_permission.op) {
+                    case 'add':
+                        this.data.biz_permission.data.forEach(v => {
+                            obj?.add_userdefine(v.index, v.name);
+                        })
+                        break;
+                    case 'remove':
+                        this.data.biz_permission.permissions.forEach(v => {
+                            obj?.remove_userdefine(v);
+                        })
+                        break;
+                }
+            }
             if (this.data?.description !== undefined && this.data.object) {
                 obj?.set_description(this.data.description)
             }
-            if (this.data?.entity !== undefined) {
-                switch (this.data.entity.op) {
+            if (this.data?.permission !== undefined) {
+                switch (this.data.permission.op) {
                     case 'add entity':
-                        obj?.add_entity(this.data.entity.entities);
+                        obj?.add_entity(this.data.permission.entities);
                         break;
                     case 'add permission':
-                        obj?.add_entity3(this.data.entity.permissions);
+                        obj?.add_entity3(this.data.permission.permissions);
                         break;
                     case 'remove entity':
-                        obj?.remove_entity(this.data.entity.addresses);
+                        obj?.remove_entity(this.data.permission.addresses);
                         break;
                     case 'remove permission':
-                        obj?.remove_index(this.data.entity.address, this.data.entity.index);
+                        obj?.remove_index(this.data.permission.address, this.data.permission.index);
                         break;
                     case 'transfer permission':
-                        obj?.transfer_permission(this.data.entity.from_address, this.data.entity.to_address);
-                        break;
-                }
-            }
-            if (this.data?.biz_permission !== undefined) {
-                switch(this.data.biz_permission.op) {
-                    case 'add':
-                        this.data.biz_permission.data.forEach(v => {
-                            obj?.add_userdefine(v.index, v.name);
-                        })
-                        break;
-                    case 'remove':
-                        this.data.biz_permission.permissions.forEach(v => {
-                            obj?.remove_userdefine(v);
-                        })
+                        obj?.transfer_permission(this.data.permission.from_address, this.data.permission.to_address);
                         break;
                 }
             }
+
             if (this.data?.builder !== undefined ) {
                 obj?.change_owner(this.data.builder);
             }

package/src/call/machine.ts

@@ -1,5 +1,4 @@
-import { TransactionBlock, CallResponse} from 'wowok';
-import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, WitnessFill,
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, TransactionBlock,
     PermissionIndexType, Machine, Machine_Forward, Machine_Node,  Deliverable, ParentProgress, Progress, ProgressNext,
 } from 'wowok';
 import { CallBase, CallResult } from "./base";
@@ -8,7 +7,6 @@ import { Account } from '../account';
 export interface CallMachine_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
-    permission_new?: string;
     bPaused?: boolean;
     bPublished?: boolean;
     consensus_repository?: {op:'set' | 'add' | 'remove' ; repositories:string[]} | {op:'removeall'};
@@ -42,9 +40,6 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
             if (!this.data?.object) {
                 perms.push(PermissionIndex.machine)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.machine_description)
             }
@@ -101,7 +96,7 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
 
             return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
 
     protected async operate(txb:TransactionBlock, passport?:PassportObject) {
@@ -203,9 +198,6 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
             if (this.data?.progress_next !== undefined) {
                 Progress.From(txb, obj?.get_object(), permission??this.data?.permission, this.data?.progress_next.progress).next(this.data.progress_next.data, this.data.progress_next.deliverable, passport)
             }
-            if (this.data?.permission_new !== undefined ) {
-                obj?.change_permission(this.data.permission_new);
-            }
             if (permission) {
                 permission.launch();
             }

package/src/call/object_permission.ts

@@ -0,0 +1,60 @@
+import { CallBase, CallResult } from "./base";
+import { TransactionBlock, CallResponse, Protocol, Demand, DemandObject, Machine, Service, Treasury, Arbitration, Repository} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, UserDefinedIndex,
+    PermissionIndexType, WitnessFill
+} from 'wowok';
+import { ObjectArbitration, ObjectDemand, ObjectMachine, ObjectRepository, ObjectService, ObjectTreasury, query_objects } from "../objects";
+
+export interface CallObjectPermission_Data {
+    objects: string[];
+    new_permission: string;
+}
+
+export class CallObjectPermission extends CallBase {
+    data: CallObjectPermission_Data;
+    constructor(data:CallObjectPermission_Data) {
+        super();
+        this.data = data;
+    }
+
+    async call(account?:string) : Promise<CallResult>   {
+        if (!IsValidAddress(this.data.new_permission)) {
+            ERROR(Errors.InvalidParam, 'CallObjectPermission_Data.new_permission' + this.data.new_permission)
+        }
+
+        if (this.data?.objects.length > 0) {
+            return await this.exec(account)
+        }
+    }
+    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+        const r = await query_objects({objects:this.data.objects, showContent:true});
+        r.objects?.forEach(v => {
+            switch(v.type) {
+            case 'Demand':
+                const demand = v as ObjectDemand;
+                Demand.From(txb, Demand.parseObjectType(demand.type_raw), demand.permission, demand.object).change_permission(this.data.new_permission);
+                break;
+            case 'Machine':
+                const machine = v as ObjectMachine;
+                Machine.From(txb, machine.permission, machine.object).change_permission(this.data.new_permission);
+                break;
+            case 'Service':
+                const service = v as ObjectService;
+                Service.From(txb, Service.parseObjectType(service.type_raw), service.permission, service.object).change_permission(this.data.new_permission);
+                break;
+            case 'Treasury':
+                const treasury = v as ObjectTreasury;
+                Treasury.From(txb, Treasury.parseObjectType(treasury.type_raw), treasury.permission, treasury.object).change_permission(this.data.new_permission);
+                break;
+            case 'Arbitration':
+                const arbitraion = v as ObjectArbitration;
+                Arbitration.From(txb, Arbitration.parseObjectType(arbitraion.type_raw), arbitraion.permission, arbitraion.object).change_permission(this.data.new_permission);
+                break;
+            case 'Repository':
+                const repository = v as ObjectRepository;
+                Repository.From(txb, repository.permission, repository.object).change_permission(this.data.new_permission);
+                break;
+            }
+        })
+    }
+}

package/src/call/personal.ts

@@ -1,17 +1,17 @@
-import { TransactionBlock, CallResponse} from 'wowok';
-import { PassportObject, IsValidAddress, Errors, ERROR, Entity, Entity_Info, MarkName, Resource, WitnessFill} from 'wowok';
+import { TransactionBlock } from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Entity, Entity_Info, GroupName, Resource, WitnessFill} from 'wowok';
 import { CallBase, CallResult } from "./base";
 
 export interface CallPersonal_Data {
     object?: string; // undefined for creating a new object
     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[]}}
+    group?: {op:'add group'; data:{group_name:string | GroupName; address:string[]}}
+        | {op:'remove group'; data:{group_name:string | GroupName; address:string[]}}
+        | {op:'clear group'; group_name:string | GroupName}
+        | {op:'add address'; data:{address:string; group_name:(string | GroupName)[]}} 
+        | {op:'remove address'; data:{address:string; group_name:(string | GroupName)[]}};
+    tag?: {op:'add'; data:{address:string; nick_name?:string; tags?:string[]}}
         | {op:'remove'; address:string};
     close?: boolean; // close a personal resource
 }
@@ -23,7 +23,7 @@ export class CallPersonal extends CallBase {
         this.data = data;
     }
     async call(account?:string) : Promise<CallResult> {
-        return this.exec(account)
+        return await this.exec(account)
     }
     protected async operate (txb:TransactionBlock, passport?:PassportObject) {
         let obj : Resource | undefined ; let entity: Entity = Entity.From(txb);
@@ -44,42 +44,42 @@ export class CallPersonal extends CallBase {
         }
 
         if (obj && obj?.get_object()) {
-            if (this.data?.marks !== undefined) {
-                switch(this.data.marks.op) {
+            if (this.data?.group !== undefined) {
+                switch(this.data.group.op) {
                     case 'add address':
-                        obj?.add2(this.data.marks.data.address, this.data.marks.data.mark_name)
+                        obj?.add2(this.data.group.data.address, this.data.group.data.group_name)
                         break;
-                    case 'add mark':
-                        if (this.data.marks.data.mark_name === MarkName.DislikeName || this.data.marks.data.mark_name === MarkName.LikeName) {
-                            const n = this.data.marks.data.mark_name;
-                            this.data.marks.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
+                    case 'add group':
+                        if (this.data.group.data.group_name === GroupName.DislikeName || this.data.group.data.group_name === GroupName.LikeName) {
+                            const n = this.data.group.data.group_name;
+                            this.data.group.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
                         } else {
-                            obj?.add(this.data.marks.data.mark_name, this.data.marks.data.address)
+                            obj?.add(this.data.group.data.group_name, this.data.group.data.address)
                         }
                         break;
-                    case 'clear mark':
-                        obj?.remove(this.data.marks.mark_name, [], true)
+                    case 'clear group':
+                        obj?.remove(this.data.group.group_name, [], true)
                         break;
                     case 'remove address':
-                        obj?.remove2(this.data.marks.data.address, this.data.marks.data.mark_name)
+                        obj?.remove2(this.data.group.data.address, this.data.group.data.group_name)
                         break;
-                    case 'remove mark':
-                        if (this.data.marks.data.mark_name === MarkName.DislikeName || this.data.marks.data.mark_name === MarkName.LikeName) {
-                            const n = this.data.marks.data.mark_name;
-                            this.data.marks.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
+                    case 'remove group':
+                        if (this.data.group.data.group_name === GroupName.DislikeName || this.data.group.data.group_name === GroupName.LikeName) {
+                            const n = this.data.group.data.group_name;
+                            this.data.group.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
                         } else {
-                            obj?.remove(this.data.marks.data.mark_name, this.data.marks.data.address)
+                            obj?.remove(this.data.group.data.group_name, this.data.group.data.address)
                         }
                         break;
                 }
             }
-            if (this.data?.tags !== undefined) {
-                switch(this.data.tags.op) {
+            if (this.data?.tag !== undefined) {
+                switch(this.data.tag.op) {
                     case 'add':
-                        obj?.add_tags(this.data.tags.data.address, this.data.tags.data.nick_name, this.data.tags.data.tags)
+                        obj?.add_tags(this.data.tag.data.address, this.data.tag.data.nick_name, this.data.tag.data.tags)
                         break;
                     case 'remove':
-                        obj?.remove_tags(this.data.tags.address)
+                        obj?.remove_tags(this.data.tag.address)
                         break;
                 }
             }

package/src/call/repository.ts

@@ -8,7 +8,6 @@ import { CallBase, CallResult} from "./base";
 export interface CallRepository_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
-    permission_new?: string; // change permission 
     description?: string;
     mode?: Repository_Policy_Mode; // default: 'Relax' (POLICY_MODE_FREE) 
     reference?: {op:'set' | 'add' | 'remove' ; addresses:string[]} | {op:'removeall'};
@@ -30,9 +29,6 @@ export class CallRepository extends CallBase {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.repository)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && this.data?.object) {
                 perms.push(PermissionIndex.repository_description)
             }
@@ -47,7 +43,7 @@ export class CallRepository extends CallBase {
             }
             return await this.check_permission_and_call(this.data.permission, perms, [], checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
 
     protected async operate(txb:TransactionBlock, passport?:PassportObject) {
@@ -124,9 +120,6 @@ export class CallRepository extends CallBase {
                         break;
                 }
             }
-            if (this.data?.permission_new !== undefined ) {
-                obj?.change_permission(this.data.permission_new);
-            }
             if (permission) {
                 permission.launch();
             }

package/src/call/service.ts

@@ -5,12 +5,12 @@ import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIn
 } from 'wowok';
 import { query_objects, ObjectService } from '../objects';
 import { CallBase, CallResult } from "./base";
+import { Account } from '../account';
 
 export interface CallService_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
     type_parameter?: string;
-    permission_new?: string;
     bPaused?: boolean;
     bPublished?: boolean;
     description?: string;
@@ -31,7 +31,7 @@ export interface CallService_Data {
         | {op:'removeall'} | {op:'remove', addresses:string[]};
     customer_required_info?: {pubkey:string; required_info:(string | BuyRequiredEnum)[]};
     sales?: {op:'add', sales:Service_Sale[]} | {op:'remove'; sales_name:string[]}
-    order_new?: {buy_items:Service_Buy[], coin_object?:string, discount?:string, machine?:string, customer_info_crypto?: Customer_RequiredInfo, guard?:string | 'fetch'}
+    order_new?: {buy_items:Service_Buy[], discount?:string, machine?:string, customer_info_crypto?: Customer_RequiredInfo, guard?:string | 'fetch'}
     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
@@ -56,9 +56,6 @@ export class CallService extends CallBase {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.service)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.service_description)
             }
@@ -144,9 +141,9 @@ export class CallService extends CallBase {
 
             return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
-    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+    protected async operate (txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Service | undefined ; let permission: any;  let payee: any;
 
         if (!this.data.object) {
@@ -300,16 +297,12 @@ export class CallService extends CallBase {
                     b += BigInt(v.max_price) * BigInt(v.count)
                 })
                 if (b > BigInt(0)) {
-                    if (this.data?.type_parameter === '0x2::sui::SUI' || this.data?.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
-                        coin = txb.splitCoins(txb.gas, [b])[0];
-                    } else if (this.data?.order_new.coin_object) {
-                        coin = txb.splitCoins(this.data.order_new.coin_object, [b])[0];
-                    }                    
-                }
-
-                if (coin) {
-                    //@ crypto tools support
-                    obj?.buy(this.data.order_new.buy_items, coin, this.data.order_new.discount, this.data.order_new.machine, this.data.order_new.customer_info_crypto, passport)                    
+                    const coin = await Account.Instance().get_coin_object(txb, b, account, this.data.type_parameter);
+                    if (coin) {
+                        //@ crypto tools support
+                        obj?.buy(this.data.order_new.buy_items, coin, this.data.order_new.discount, 
+                            this.data.order_new.machine, this.data.order_new.customer_info_crypto, passport)                    
+                    }                 
                 }
             }
             if (this.data?.order_payer !== undefined && obj) {
@@ -331,9 +324,6 @@ export class CallService extends CallBase {
             if (this.data?.order_withdrawl !== undefined && passport) { //@ need withdrawal passport
                 obj?.withdraw(this.data.order_withdrawl.order, this.data.order_withdrawl.data, passport)
             }
-            if (this.data?.permission_new !== undefined) {
-                obj?.change_permission(this.data.permission_new);
-            }
             if (permission) {
                 permission.launch();
             }

package/src/call/treasury.ts

@@ -4,17 +4,17 @@ import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIn
 } from 'wowok';
 import { query_objects, ObjectTreasury } from '../objects';
 import { CallBase, CallResult } from "./base";
+import { Account } from '../account';
 
 export interface CallTreasury_Data {
     object?: string; // undefined for creating a new object
     permission?: string; 
     type_parameter?: string;
-    permission_new?: string;
     description?: string;
     withdraw_mode?: Treasury_WithdrawMode;
     withdraw_guard?: {op:'add' | 'set'; data:{guard:string, amount:string}[]} | {op:'remove', guards:string[]} | {op:'removeall'};
     deposit_guard?: string;
-    deposit?: {data:DepositParam, guard?:string | 'fetch'};
+    deposit?: {data:{balance:string|number; index?:number; remark?:string; for_object?:string; for_guard?:string}; guard?:string | 'fetch'};
     receive?: {payment:string; received_object:string};
     withdraw?:WithdrawParam;
 }
@@ -37,9 +37,6 @@ export class CallTreasury extends CallBase {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.treasury)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.treasury_descritption)
             }
@@ -100,9 +97,9 @@ export class CallTreasury extends CallBase {
 
             return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
-        return this.exec(account);
+        return await this.exec(account);
     }
-    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+    protected async operate (txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Treasury | undefined ; let permission: any; 
         if (!this.data.object) {
             if (!this.data?.permission || !IsValidAddress(this.data?.permission)) {
@@ -149,10 +146,14 @@ export class CallTreasury extends CallBase {
                 obj?.receive(this.data.receive.payment, this.data.receive.received_object, passport); 
             }
             if (this.data.deposit !== undefined) {
-                obj?.deposit(this.data.deposit.data, passport)
-            }
-            if (this.data?.permission_new !== undefined) {
-                obj?.change_permission(this.data.permission_new);
+                const coin = await Account.Instance().get_coin_object(txb, this.data.deposit.data.balance, account, this.data.type_parameter);
+                if (coin) {
+                    const index = this.data.deposit.data?.index ?? 0;
+                    obj?.deposit({coin:coin, index:BigInt(index), remark:this.data.deposit.data.remark ??'', 
+                        for_guard:this.data.deposit.data?.for_guard,
+                        for_object: this.data.deposit.data?.for_object
+                    })
+                }
             }
             if (permission) {
                 permission.launch();

package/src/call.ts

@@ -8,19 +8,20 @@
 import { CallArbitration, CallArbitration_Data } from "./call/arbitration";
 import { CallDemand, CallDemand_Data } from "./call/demand";
 import { CallMachine, CallMachine_Data } from "./call/machine";
-import { CallPermission, CallPermission_Data } from "./call/permission";
+import { CallEntityPermission, CallEntityPermission_Data } from "./call/entity_permission";
 import { CallPersonal, CallPersonal_Data } from "./call/personal";
 import { CallRepository, CallRepository_Data } from "./call/repository";
 import { CallService, CallService_Data } from "./call/service";
 import { CallTreasury, CallTreasury_Data } from "./call/treasury";
 import { CallBase, CallResult, CallWithWitnessParam } from "./call/base";
 import { CallGuard, CallGuard_Data } from "./call/guard";
+import { CallObjectPermission, CallObjectPermission_Data } from "./call/object_permission";
 
  
 export interface CallObjectData {
-    type: 'Demand' | 'Service' | 'Machine' | 'Treasury' | 'Arbitration' | 'Guard' | 'Repository' | 'Personal' | 'Permission';
-    data: CallDemand_Data | CallMachine_Data | CallArbitration_Data | CallPermission_Data | CallPermission_Data
-    | CallTreasury_Data | CallService_Data | CallPermission_Data | CallRepository_Data;
+    type: 'Demand' | 'Service' | 'Machine' | 'Treasury' | 'Arbitration' | 'Guard' | 'Repository' | 'Personal' | 'EntityPermission' | 'ObjectPermission';
+    data: CallDemand_Data | CallMachine_Data | CallArbitration_Data | CallEntityPermission_Data | CallObjectPermission_Data
+    | CallTreasury_Data | CallService_Data  | CallRepository_Data;
     account?: string;
     witness?: CallWithWitnessParam;
 }
@@ -64,7 +65,9 @@ function call_object_new (call: CallObjectData) : CallBase | undefined {
             return new CallRepository(call.data as CallRepository_Data);
         case 'Personal':
             return new CallPersonal(call.data as CallPersonal_Data);
-        case 'Permission':
-            return new CallPermission(call.data as CallPermission_Data);
+        case 'EntityPermission':
+            return new CallEntityPermission(call.data as CallEntityPermission_Data);
+        case 'ObjectPermission':
+            return new CallObjectPermission(call.data as CallObjectPermission_Data);
     }
 }

package/src/entity.ts

@@ -0,0 +1,60 @@
+import { Bcs, Entity, Entity_Info, ERROR, Errors, IsValidAddress, Protocol, TransactionBlock } from "wowok";
+import { CacheName, PERSONAL_RESOURCE_KEY, WowokCache, CachedData} from "./cache";
+
+export interface EntityAnswer {
+    info?: Entity_Info;
+    resource?: string;
+    like?: number;
+    dislike?: number;
+}
+
+export const query_entity_json = async (person_address:string) : Promise<string> => {
+    try {
+        return JSON.stringify({data:await query_entity(person_address)});
+    } catch (e) {
+        return JSON.stringify({error:e?.toString()})
+    }
+}
+
+export const query_entity = async (personal_address:string) : Promise<EntityAnswer | undefined> => {
+    if (!IsValidAddress(personal_address)) {
+        ERROR(Errors.InvalidParam, 'personal_address - '+personal_address)
+    }
+
+    const cache = WowokCache.Instance().get(CacheName.resource);
+
+    if (cache) {
+        const now = new Date().getTime(); 
+        const data = cache.load(PERSONAL_RESOURCE_KEY(personal_address));
+        if (data) {
+            const r:CachedData = JSON.parse(data);
+            if (r.expire !== 'INFINITE' && r.expire >= now) { //update , INFINITE not supported
+                return JSON.parse(r.data) as EntityAnswer
+            }
+        } 
+    }
+
+    const e = await entity(personal_address);
+    if (e) {
+        if (cache) { // save
+            const r:CachedData = {expire:new Date().getTime(), data:JSON.stringify(e)}
+            cache.save(PERSONAL_RESOURCE_KEY(personal_address), JSON.stringify(r));
+        }
+        return e
+    }
+}
+
+const entity = async (personal_address:string) : Promise<EntityAnswer | undefined> => {
+    const txb = new TransactionBlock();
+    Entity.From(txb).query_ent(personal_address);
+
+    const res = await Protocol.Client().devInspectTransactionBlock({sender:personal_address, transactionBlock:txb});
+    if (res.results?.length === 1 && res.results[0].returnValues?.length === 1 )  {
+        const r = Bcs.getInstance().de_ent(Uint8Array.from(res.results[0].returnValues[0][0]));
+        const info = Bcs.getInstance().de_entInfo(Uint8Array.from(r?.avatar));
+        const d : EntityAnswer = {resource:r?.resource?.some, like:r?.like, dislike:r?.dislike, info: {
+            avatar:info.avatar, name:info.name, twitter:info.twitter, discord:info.discord, homepage:info.homepage, description:info.description
+        }};  
+        return d;
+    }
+}

package/src/index.ts

@@ -3,10 +3,10 @@ export * from './permission'
 export * from './events'
 export * from './cache'
 export * from './call/base'
-export * from './call/permission'
+export * from './call/entity_permission'
 export * from './call/arbitration'
 export * from './call/treasury'
-export * from './call/permission'
+export * from './call/entity_permission'
 export * from './call/demand'
 export * from './call/machine'
 export * from './call/repository'

package/src/objects.ts

@@ -5,20 +5,21 @@
 
 import { Protocol, Machine_Node, Machine, Treasury_WithdrawMode, Treasury_Operation,
     Repository_Type, Repository_Policy_Mode, Repository_Policy, Service_Discount_Type, Service_Sale,
-    Progress, History, ERROR, Errors, IsValidAddress, Bcs, 
+    Progress, History, ERROR, Errors, IsValidAddress, Bcs,
+    Entity_Info, Tags
  } from 'wowok';
-import {WowokCache, OBJECT_KEY} from './cache'
+import {WowokCache, OBJECT_KEY, CacheExpire, CacheName, CachedData} from './cache'
 
 export interface ObjectBase {
     object: string;
     type?: string | 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' |
-        'Entity' | 'Permission' | 'Resource' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
+        'Entity' | 'Permission' | 'Mark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
         'TableItem_DemandPresenter' | 'TableItem_MachineNode' | 'TableItem_ServiceSale' | 'TableItem_TreasuryHistory' | 'TableItem_ArbVote' |
-        'TableItem_RepositoryData' | 'TableItem_ResourceMark';
+        'TableItem_RepositoryData' | 'TableItem_MarkGroup' | 'TableItem_MarkTag';
     type_raw?: string;
     owner?: any;
     version?: string;
-    cache_expire?: number | 'INFINITE';
+    cache_expire?: CacheExpire;
 }
 
 export interface ObjectPermission extends ObjectBase {
@@ -220,32 +221,22 @@ export interface ObjectEntity extends ObjectBase {
     address: string; 
     like: number;
     dislike: number;
-
-    name?: string;
-    description?: string;
-    avatar?: string;
-    x?: string;
-    discord?: string;
-
-    homepage?: string;
+    info: Entity_Info;
     resource_object?: string | null;
     lastActive_digest?: string; 
 }
 
-export interface ObjectResouorce_Tag {
-    object: string;
-    nick_name: string;
-    tags: string[];
+export interface ObjectMark extends ObjectBase {
+    group_count: number;
+    tag_count: number;
 }
 
-export interface ObjectResouorce extends ObjectBase {
-    marks_count: number;
-    tags: ObjectResouorce_Tag[];
+export interface TableItem_MarkGroup extends ObjectBase {
+    group_name: string;
+    address: string[];
 }
 
-export interface TableItem_ResourceMark extends ObjectBase {
-    mark_name: string;
-    objects: string[];
+export interface TableItem_MarkTag extends ObjectBase, Tags {
 }
 
 export enum CacheType {
@@ -287,11 +278,6 @@ interface TableItemQuery {
     key: {type:string, value:unknown};
 }
 
-export interface CachedData {
-    expire: number | 'INFINITE';
-    data: string | any; 
-}
-
 /* json: ObjectsQuery string */
 export const query_objects_json = async (json:string) : Promise<string> => {
     try {
@@ -314,8 +300,8 @@ export const query_table_json = async (json:string) : Promise<string> => {
 
 export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
     var ret:ObjectBase[] = []; const pending : string[] = [];
-    let bCached = true; const time = new Date().getTime();
-    const cache = WowokCache.Instance().get();
+    const time = new Date().getTime();
+    const cache = WowokCache.Instance().get(CacheName.object);
     if (cache) {
         for (let i = 0; i < query.objects.length; ++i) {
             try {
@@ -342,10 +328,10 @@ export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer
     if (pending.length > 0) {
         const res = await Protocol.Client().multiGetObjects({ids:[...pending], 
             options:{showContent:query.showContent, showType:query.showType, showOwner:query.showOwner}});
-        const now = new Date().getTime(); 
-        const cache = WowokCache.Instance().get();
+        const cache = WowokCache.Instance().get(CacheName.object);
         
         if (cache) {
+            const now = new Date().getTime(); 
             res.forEach((i) => { // save
                 try {
                     if (i?.data) {
@@ -363,7 +349,7 @@ export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer
     return {objects:ret}
 }
 
-export const query_entity = async (address:string) : Promise<ObjectEntity> => {
+export const queryTableItem_Personal = async (address:string) : Promise<ObjectEntity> => {
     if (!IsValidAddress(address))  ERROR(Errors.IsValidAddress, 'entity.address')
     const res = await Protocol.Client().getDynamicFieldObject({parentId:Protocol.Instance().objectEntity(), name:{type:'address', value:address}});
     return data2object(res?.data) as ObjectEntity
@@ -405,7 +391,7 @@ export const tableItemQuery_RepositoryData = async (repository_object:string | O
     }
     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> => {
+export const tableItemQuery_ResourceGroup = async (resource_object:string | ObjectMark, name:string) : Promise<ObjectBase> => {
     return await tableItem(tableItemQuery_byString(resource_object, name))
 }
 
@@ -415,7 +401,7 @@ function tableItemQuery_byAddress(parent:string | ObjectDemand | ObjectPermissio
     }
     return {parent:parent, key:{type:'address', value:address}};
 }
-function tableItemQuery_byString(parent:string | ObjectMachine | ObjectService | ObjectResouorce, name:string) : TableItemQuery  {
+function tableItemQuery_byString(parent:string | ObjectMachine | ObjectService | ObjectMark, name:string) : TableItemQuery  {
     if (typeof(parent) !== 'string') {
         parent = parent.object;
     }
@@ -581,11 +567,9 @@ export function data2object(data?:any) : ObjectBase {
         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;   
+                group_count:parseInt(content?.marks?.fields?.size),
+                tag_count:parseInt(content?.tags?.fields?.size)
+            } as ObjectMark;   
         }
     } 
     
@@ -644,15 +628,19 @@ export function data2object(data?:any) : ObjectBase {
                 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
+                    resource_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 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;
+                    object:id, type:'TableItem_MarkGroup', type_raw:type_raw, owner:owner, version:version,
+                    group_name:content?.name, address:content?.value?.fields?.addresses
+                } as TableItem_MarkGroup;
+            } else if (end.includes('::resource::Tags>')) {
+                return {object:id, type:'TableItem_MarkTag', type_raw:type_raw, owner:owner, version:version,
+                    address:content?.name, nick:content?.value?.fields?.nick, tags:content?.value?.fields?.tags
+                } as TableItem_MarkTag;
             }
         }
     }

package/src/permission.ts

@@ -4,7 +4,7 @@
  */
 
 import { TransactionBlock, } from 'wowok';
-import { Protocol, Bcs, IsValidAddress, Errors, ERROR, Permission, PermissionAnswerItem, PermissionAnswer, BCS} from 'wowok';
+import { Protocol, Bcs, IsValidAddress, Errors, ERROR, Permission, PermissionAnswer, BCS} from 'wowok';
 
 
 export interface PermissionQuery {