wowok_agent 1.2.35 → 1.2.38

package/src/call/treasury.ts

@@ -64,7 +64,7 @@ export class CallTreasury extends CallBase {
                         }
                     } else {
                         if (!obj) {
-                            const r = await query_objects({objects:[object_address], showContent:true});
+                            const r = await query_objects({objects:[object_address]});
                             if (r?.objects && r.objects[0].type === 'Treasury') {
                                 obj = r.objects[0] as ObjectTreasury;
                             }
@@ -84,7 +84,7 @@ export class CallTreasury extends CallBase {
                     guards.push(this.data.withdraw.withdraw_guard)
                 } else if (this.data.object) {
                     if (!obj) {
-                        const r = await query_objects({objects:[object_address], showContent:true});
+                        const r = await query_objects({objects:[object_address]});
                         if (r?.objects && r.objects[0].type === 'Treasury') {
                             obj = r.objects[0] as ObjectTreasury;
                         }

package/src/index.ts

@@ -16,4 +16,6 @@ export * from './call/call.js'
 export * from './local/account.js'
 export * from './local/cache.js'
 export * from './local/local.js'
+export * from './local/index.js'
+
 export * as WOWOK from 'wowok'

package/src/local/account.ts

@@ -76,7 +76,7 @@ export class Account {
     }
     
     async list() : Promise<string[]> {
-        return await this.storage.keys().all();
+        return (await this.storage.keys().all()).filter(v => v !== SettingDefault);
     }
     
     async faucet(address?:string) {
@@ -160,6 +160,24 @@ export class Account {
             }
         }
     }
+    async transfer(from:string, to:string, amount:number|string, token_type?:string) : Promise<CallResponse | undefined> {
+        const secret: string | undefined = await this.storage.get(from);    
+        if (!secret)    return undefined;
+        const pair = Ed25519Keypair.fromSecretKey(fromHEX(secret))
+        if (!pair) return undefined;
+
+        const txb = new TransactionBlock();
+        const coin = await this.get_coin_object(txb, amount, from, token_type);
+        if (coin) {
+            txb.transferObjects([(coin as unknown) as TransactionArgument], to)
+            const r = await Protocol.Client().signAndExecuteTransaction({
+                transaction: txb, 
+                signer: pair,
+                options:{showObjectChanges:true},
+            });
+            return r;
+        }
+    }
 
     coinObject_with_balance = async(balance_required:string | bigint | number, address?:string, token_type?:string) : Promise<string | undefined> => {
         if (!address) {

package/src/local/index.ts

@@ -0,0 +1,140 @@
+import { CallResponse, CoinBalance, CoinStruct } from "wowok"
+import { Account } from "./account.js"
+import { LocalInfo, LocalInfoNameDefault, LocalMark, LocalMarkFilter, MarkData } from "./local.js"
+
+export const query_local_mark_list = async (filter?:LocalMarkFilter) : Promise<string> => {
+    return JSON.stringify(await LocalMark.Instance().list(filter))
+}
+
+export const query_account_list = async () : Promise<QueryAccountsResult> => {
+    const res : QueryAccountsResult = {};
+    res.addresses = await Account.Instance().list();
+    res.default = await Account.Instance().default(false);
+    return res;
+}
+
+export const query_local_info_list = async () : Promise<string> => {
+    return JSON.stringify(await LocalInfo.Instance().list())
+}
+
+export interface QueryAccountsResult {
+    default?: string;
+    addresses?: string[];
+}
+
+export const query_local_mark = async (name: string) : Promise<MarkData | undefined> => {
+    return await LocalMark.Instance().get(name)
+}
+
+
+export enum BalanceOrCoin {
+    Balance = 'balance',
+    Coin = 'coin'
+}
+
+export interface QueryAccount {
+    name_or_address?: string; // undifined if query the default account. 
+    balance_or_coin?: BalanceOrCoin;
+    token_type?:string; // 0x2::sui::SUI, if not specified.
+}
+
+export interface QueryAccountResult {
+    name_or_address?: string; 
+    address?: string;
+    balance?: CoinBalance;
+    coin?: CoinStruct[];
+}
+
+export const query_account = async (query: QueryAccount) : Promise<QueryAccountResult> => {
+    const r = await LocalMark.Instance().get_account(query.name_or_address);
+    const res : QueryAccountResult = {address: r};
+    if (query.name_or_address) { res.name_or_address = query.name_or_address; }
+
+    if (r) {
+        if (query?.balance_or_coin === BalanceOrCoin.Balance) {
+            res.balance = await Account.Instance().balance(r, query.token_type);
+        } else if (query?.balance_or_coin === BalanceOrCoin.Coin) {
+            res.coin =  await Account.Instance().coin(r, query.token_type);
+        } 
+    } 
+    
+    return res;
+}
+
+export const query_local_info = async (name: string = LocalInfoNameDefault) : Promise<LocalInfo | undefined> => { 
+    return await LocalInfo.Instance().get(name)
+}
+
+export interface AccountOperation {
+    gen?: {name?:string, default?: boolean, useAddressIfNameExist?: boolean};
+    transfer?: {name_or_address_from?: string, name_or_address_to?:string, amount:number|string, token_type?: string};
+}
+
+export interface AccountOperationResult {
+    gen?: {address:string};
+    transfer?: CallResponse;
+}
+
+export const account_operation = async(op: AccountOperation) : Promise<AccountOperationResult> => {
+    var res : AccountOperationResult = {};
+    if (op.gen) {
+        const acc = await Account.Instance().gen(op.gen.default);
+        if (await LocalMark.Instance().put(op.gen.name, {object: acc, tags: ['account']}, op.gen.useAddressIfNameExist)) {
+            res.gen = {address: acc};
+        }
+    } else if (op.transfer) {
+        const from = await LocalMark.Instance().get_account(op.transfer.name_or_address_from);
+        const to = await LocalMark.Instance().get_account(op.transfer.name_or_address_to);
+        if (from && to) {
+            res.transfer = await Account.Instance().transfer(from, to, op.transfer.amount, op.transfer.token_type);
+        }
+    } 
+    return res;
+}
+
+export interface LocalMarkOperation {
+    removeall?: boolean;
+    add_or_set?: {name:string, address:string, tags?:string[], useAddressIfNameExist?:boolean}[];
+    remove?: string[];
+}
+
+export const local_mark_operation = async(op: LocalMarkOperation) : Promise<void> => {
+    if (op.removeall) {
+        await LocalMark.Instance().clear();
+    } else if (op.add_or_set) {
+        for (let i = 0; i < op.add_or_set.length; ++ i) {
+            const v = op.add_or_set[i];
+            await LocalMark.Instance().put(v.name, {object: v.address, tags: v.tags}, v.useAddressIfNameExist);
+        }
+    } else if (op.remove) {
+        for (let i = 0; i < op.remove.length; ++ i) {
+            const v = op.remove[i];
+            await LocalMark.Instance().del(v);
+        }
+    }
+    return undefined;
+}   
+
+export interface LocalInfoOperation {
+    removeall?: boolean;
+    add?: {name:string, content:string, bdefault?: boolean}[];
+    remove?: string[];
+}
+
+export const local_info_operation = async(op: LocalInfoOperation) : Promise<void> => {
+    if (op.removeall) {
+        await LocalInfo.Instance().clear();
+    }
+    else if (op.add) {  
+        for (let i = 0; i < op.add.length; ++ i) {
+            const v = op.add[i];
+            await LocalInfo.Instance().put(v.name, v.content, v.bdefault);
+        }
+    }
+    else if (op.remove) {   
+        for (let i = 0; i < op.remove.length; ++ i) {
+            const v = op.remove[i];
+            await LocalInfo.Instance().del(v);
+        }
+    }
+}

package/src/local/local.ts

@@ -7,7 +7,7 @@ import path from "path";
 import os from "os";
 import { Level } from "level";
 import { isBrowser } from "../common.js";
-import { IsValidAddress } from "wowok";
+import { IsValidAddress, TagName } from "wowok";
 import { Account } from "./account.js";
 
 export interface MarkData {
@@ -20,10 +20,16 @@ export interface InfoData {
   others?: string[];
 }
 
+export interface LocalMarkFilter {
+  name?: string;
+  tags?: string[];
+  object?: string;
+}
+
 export const LocalMarkLocation = 'wowok-mark';
 export const LocalInfoLocation = 'wowok-info';
 export const LocalMarkNameMaxLength = 32;
-
+export const LocalInfoNameDefault = 'Address of delivery';
 export class LocalMark {
     static _instance: any;
     private storage;
@@ -101,7 +107,7 @@ export class LocalMark {
   
           if (genNewIfNotFound) {
             const addr = await Account.Instance().gen(false);
-            await this.put(name_or_address, {object:addr});
+            await this.put(name_or_address, {object:addr, tags:[TagName.Account]});
           }
         }
       }
@@ -149,8 +155,27 @@ export class LocalMark {
       }
       return false;
     }
+
+    async list(filter?: LocalMarkFilter) : Promise<QueryNameData[]> {
+      return (await this.storage.iterator().all()).filter(v => {
+        const obj = JSON.parse(v[1]) as MarkData;
+        if (filter?.name && v[0] !== filter.name) return false;
+        if (filter?.object && obj.object !== filter.object) return false;
+        if (filter?.tags && obj.tags) {
+          for (let i = 0; i < filter.tags.length; ++ i) {
+            if (!obj.tags.includes(filter.tags[i])) return false;
+          }
+        }
+        return true;
+      }).map(v => {return {name:v[0], data:v[1]}});
+    }
 }
 
+export interface QueryNameData {
+  name: string;
+  data: any;
+};
+
 export class LocalInfo {
   static _instance: any;
   private storage;
@@ -169,7 +194,7 @@ export class LocalInfo {
       }; return LocalInfo._instance
   } 
 
-  async put(name:string, content:string, bDefault:boolean=true) : Promise<void> {
+  async put(name:string = LocalInfoNameDefault, content:string, bDefault:boolean=true) : Promise<void> {
     const r = await this.storage.get(name);
     if (r)  {
       const obj = JSON.parse(r) as InfoData;
@@ -185,25 +210,25 @@ export class LocalInfo {
     }
   }
 
-  async get(name: string) : Promise<LocalInfo | undefined> {
+  async get(name: string = LocalInfoNameDefault) : Promise<LocalInfo | undefined> {
     const r = await this.storage.get(name);
     if (r) {
         return JSON.parse(r);
     }
   }
 
-  async get_default(name: string) : Promise<string | undefined> {
+  async get_default(name: string = LocalInfoNameDefault) : Promise<string | undefined> {
     const r = await this.storage.get(name);
     if (r) {
         return (JSON.parse(r) as InfoData).default;
     }
   }
 
-  async del(name:string)  {
-    return await this.storage.del(name);
+  async del(name:string = LocalInfoNameDefault) : Promise<void> {
+    await this.storage.del(name);
   }
 
-  async del_content(name:string, index:number) : Promise<boolean> {
+  async del_content(name:string = LocalInfoNameDefault, index:number) : Promise<boolean> {
     const r = await this.storage.get(name);
     if (r) {
         const obj =  JSON.parse(r) as InfoData;
@@ -219,5 +244,9 @@ export class LocalInfo {
   async clear() {
     return await this.storage.clear();
   }
+
+  async list() : Promise<QueryNameData[]> {
+    return (await this.storage.iterator().all()).map(v => {return {name:v[0], data:v[1]}});
+  }
 }
 

package/src/query/objects.ts

@@ -235,9 +235,6 @@ export interface TableItem_PersonalMark extends ObjectBase, Tags {
 
 export interface ObjectsQuery {
     objects: string[];
-    showType?: boolean;
-    showContent?: boolean;
-    showOwner?: boolean;
     no_cache?: boolean;
 }
 
@@ -306,12 +303,11 @@ export const query_personal_json = async (json:string) : Promise<string> => {
 
 export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
     var ret:ObjectBase[] = []; var pending : string[] = [];
-    const showTypeOnly = !(query.showContent || query.showContent);
 
-    if (!query.no_cache || (query.no_cache && showTypeOnly)) { // showType only, use cache
+    if (!query.no_cache) { // showType only, use cache
         for (let i = 0; i < query.objects.length; ++i) {
             try {
-                const cache = await Cache.Instance().cache_get(query.objects[i], CacheName.object, showTypeOnly);
+                const cache = await Cache.Instance().cache_get(query.objects[i], CacheName.object);
                 
                 if (cache) {
                     const d = data2object(JSON.parse(cache.data));
@@ -324,11 +320,13 @@ export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer
             } catch (e) { /*console.log(e)*/}
             pending.push(query.objects[i]);
         }
+    } else {
+        pending = [...query.objects];
     }
 
     if (pending.length > 0) {
         const res = await Protocol.Client().multiGetObjects({ids:[...pending], 
-            options:{showContent:query.showContent, showType:query.showType, showOwner:query.showOwner}});
+            options:{showContent:true, showOwner:true}});
 
         for (let i = 0; i < res.length; ++i) {
             const d = res[i]?.data;
@@ -474,6 +472,9 @@ export const queryTableItem_ProgressHistory = async (query:QueryTableItem_Index)
 export const queryTableItem_TreasuryHistory = async (query:QueryTableItem_Index) : Promise<ObjectBase> => {
     return await tableItemQuery_byIndex(query)
 }
+export const queryTableItem_MarkTag = async (query:QueryTableItem_Address) : Promise<ObjectBase> => {
+    return await tableItemQuery_byAddress(query)
+}
 
 const tableItemQuery_byAddress = async (query:QueryTableItem_Address) : Promise<ObjectBase> => {
     const parent = typeof(query.parent) === 'string' ? query.parent : query.parent.object;