wowok_agent 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok_agent",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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,13 +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;
@@ -101,7 +102,7 @@ export class CallArbitration extends CallBase {
         }
         return 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)) {
@@ -176,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({
@@ -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,9 +1,9 @@
-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
@@ -13,7 +13,7 @@ export interface CallDemand_Data {
     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;
@@ -77,7 +77,7 @@ export class CallDemand extends CallBase {
         }
         return 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 +109,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);

package/src/call/guard.ts

@@ -64,7 +64,6 @@ export class CallGuard extends CallBase {
         const bytes = (concatenate(Uint8Array, ...output) as Uint8Array); 
         const txb = new TransactionBlock();
     
-        console.log(bytes)
         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()))],  
@@ -106,13 +105,11 @@ export class CallGuard extends CallBase {
 const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'variable', table:GuardConst[], output:Uint8Array[]) => {
     const node: any = guard_node as any;
     if (node?.identifier !== undefined) {
-        console.log(node)
         const f = table.find(v=>v.identifier === node.identifier);
         if (f) {
             checkType(f.value_type, type_required, node);
             output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT)); 
             output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.identifier))
-            console.log(2)
         } else {
             ERROR(Errors.InvalidParam, 'node identifier - ' + node.toString());
         }

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";

package/src/call/personal.ts

@@ -1,22 +1,22 @@
-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
 }
 
-export class CallEntity extends CallBase {
+export class CallPersonal extends CallBase {
     data: CallPersonal_Data;
     constructor(data: CallPersonal_Data) {
         super();
@@ -44,42 +44,42 @@ export class CallEntity 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/service.ts

@@ -5,6 +5,7 @@ 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
@@ -31,7 +32,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
@@ -146,7 +147,7 @@ export class CallService extends CallBase {
         }
         return 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 +301,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) {

package/src/call/treasury.ts

@@ -4,6 +4,7 @@ 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
@@ -14,7 +15,7 @@ export interface CallTreasury_Data {
     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;
 }
@@ -102,7 +103,7 @@ export class CallTreasury extends CallBase {
         }
         return 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,7 +150,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)
+                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 (this.data?.permission_new !== undefined) {
                 obj?.change_permission(this.data.permission_new);

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

@@ -12,4 +12,6 @@ export * from './call/machine'
 export * from './call/repository'
 export * from './call/service'
 export * from './call/guard'
+export * from './call/personal'
 export * from './account'
+export * from './call'

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, 
  } 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';
     type_raw?: string;
     owner?: any;
     version?: string;
-    cache_expire?: number | 'INFINITE';
+    cache_expire?: CacheExpire;
 }
 
 export interface ObjectPermission extends ObjectBase {
@@ -220,31 +221,24 @@ 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 {
+export interface ObjectMark_Tag {
     object: string;
     nick_name: string;
     tags: string[];
 }
 
-export interface ObjectResouorce extends ObjectBase {
-    marks_count: number;
-    tags: ObjectResouorce_Tag[];
+export interface ObjectMark extends ObjectBase {
+    group_count: number;
+    tags: ObjectMark_Tag[];
 }
 
-export interface TableItem_ResourceMark extends ObjectBase {
-    mark_name: string;
+export interface TableItem_MarkGroup extends ObjectBase {
+    group_name: string;
     objects: string[];
 }
 
@@ -287,11 +281,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 +303,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 +331,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 +352,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 +394,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 +404,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 +570,11 @@ 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),
+                group_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;   
+            } as ObjectMark;   
         }
     } 
     
@@ -644,15 +633,15 @@ 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;
+                    group_name:content?.name, objects:content?.value?.fields?.addresses
+                } as TableItem_MarkGroup;
             }
         }
     }

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 {