wowok_agent 1.2.37 → 1.2.40

package/src/local/index.ts

@@ -66,75 +66,79 @@ export const query_local_info = async (name: string = LocalInfoNameDefault) : Pr
 }
 
 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};
+    gen?: {name?:string, default?: boolean, useAddressIfNameExist?: boolean} | null;
+    transfer?: {name_or_address_from?: string, name_or_address_to?:string, amount:number|string, token_type?: string} | null; 
 }
 
 export interface AccountOperationResult {
-    gen?: {address:string};
+    gen?: {address:string, default:boolean, name: string};
     transfer?: CallResponse;
 }
 
 export const account_operation = async(op: AccountOperation) : Promise<AccountOperationResult> => {
-    var res : 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);
+        const acc = await Account.Instance().gen(op.gen?.default);
+        const name = await LocalMark.Instance().put(op.gen.name, {object: acc, tags: ['account']}, op.gen.useAddressIfNameExist);
+        res.gen =  {address: acc, default: op.gen.default ?? false, name:name};
+    } 
+    
+    if(op.transfer) {
+        const from = await LocalMark.Instance().get_account(op.transfer?.name_or_address_from, false);
+        const to = await LocalMark.Instance().get_account(op.transfer.name_or_address_to, false);
         if (from && to) {
-            res.transfer = await Account.Instance().transfer(from, to, op.transfer.amount, op.transfer.token_type);
+            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 interface LocalMarkOperation { data: {op: 'removeall' } 
+    | {op:'add', data:{name:string, address:string, tags?:string[], useAddressIfNameExist?:boolean}[]}
+    | {op:'remove', data: 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);
-        }
+    switch(op.data?.op) {
+        case 'removeall':
+            return await LocalMark.Instance().clear();
+        case 'add':
+            for (let i = 0; i < op.data.data.length; ++ i) {
+                const v = op.data.data[i];
+                await LocalMark.Instance().put(v.name, {object: v.address, tags: v.tags}, v.useAddressIfNameExist);
+            };
+            return ;
+        case 'remove':
+            for (let i = 0; i < op.data.data.length; ++ i) {
+                const v = op.data.data[i];
+                await LocalMark.Instance().del(v);
+            }
+            return     
     }
-    return undefined;
 }   
 
-export interface LocalInfoOperation {
-    removeall?: boolean;
-    add?: {name:string, content:string, bdefault?: boolean}[];
-    remove?: string[];
-}
+export interface LocalInfoOperation { 
+    data: {op: 'removeall' } 
+    | {op:'add', data:{name:string, content:string, bdefault?: boolean}[]}
+    | {op:'remove', data: 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);
-        }
+    switch (op.data?.op) {
+        case 'removeall':
+            await LocalInfo.Instance().clear();
+            break;
+        case 'add' :
+            for (let i = 0; i < op.data?.data.length; ++ i) {
+                const v = op.data.data[i];
+                await LocalInfo.Instance().put(v.name, v.content, v?.bdefault);
+            }
+            break;
+        case 'remove' :   
+            for (let i = 0; i < op.data?.data.length; ++ i) {
+                const v = op.data.data[i];
+                await LocalInfo.Instance().del(v);
+            }
+            break;
     }
 }

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, TagName } from "wowok";
+import { ERROR, Errors, IsValidAddress, TagName } from "wowok";
 import { Account } from "./account.js";
 
 export interface MarkData {
@@ -50,16 +50,16 @@ export class LocalMark {
 
     // useAddressIfNameExist true: use address as the name if the name exist; 
     // otherwise, use this name and change the original name to its address.
-    async put(name:string | undefined | null, mark:MarkData, useAddressIfNameExist?:boolean) : Promise<boolean> {
+    async put(name:string | undefined | null, mark:MarkData, useAddressIfNameExist?:boolean) : Promise<string> {
       // object address invalid
       if (!IsValidAddress(mark.object) && mark.object !== '0x2' && mark.object !== '0x6') { 
-        return false;
+        ERROR(Errors.InvalidParam, `LocalMark.put.mark.object: ${mark.object}`)
       };
 
       // use address as name if name is undefined or null
       if (name === undefined || name === null) {
         this.storage.put(mark.object, JSON.stringify(mark));
-        return true;
+        return mark.object
       }
 
       if (name.length > LocalMarkNameMaxLength) {
@@ -70,7 +70,7 @@ export class LocalMark {
       if (r) {
         if (useAddressIfNameExist) {
           this.storage.put(mark.object, JSON.stringify(mark));
-          return true;
+          return mark.object
         } else {
           const obj = JSON.parse(r) as MarkData;
           await this.storage.put(obj.object, r)
@@ -78,7 +78,7 @@ export class LocalMark {
       }
 
       await this.storage.put(name, JSON.stringify(mark));
-      return true;
+      return name
     }
 
     async get(name: string) : Promise<MarkData | undefined> {
@@ -88,6 +88,39 @@ export class LocalMark {
       }
     }
 
+    async get_address(name_or_address?: string | null) : Promise<string | undefined> {
+      if (IsValidAddress(name_or_address)) {
+        return name_or_address!;
+      }
+
+      if (name_or_address !== undefined && name_or_address !== null) {
+        const r = await this.storage.get(name_or_address);
+        if (r) {
+            return JSON.parse(r).object;
+        }     
+      }
+    }
+
+    async get_many_address(name_or_addresses: (string | null | undefined)[]) : Promise<(string | undefined)[]> {
+      const check = (v: string | null | undefined) : boolean => {
+        return v!==undefined && v!==null && !IsValidAddress(v)
+      }
+      const q = await this.storage.getMany((name_or_addresses.filter(v => check(v)) as string[]));
+      return name_or_addresses.map(v => {
+        if (check(v)) {
+          const r = q.shift();
+          if (r) {
+            return JSON.parse(q.shift()!)?.object;
+          } 
+        } 
+        return v
+      })
+    }
+
+    async get_many_address2(name_or_addresses: (string | null | undefined)[]) : Promise<string[]> {
+      return (await this.get_many_address(name_or_addresses)).filter(v => v!==undefined && v!== null) as string[]
+    }
+
     // get account address:
     // 1. if name_or_address is undefined, return default account address.
     // 2. if name_or_address is address, return it.
@@ -157,13 +190,20 @@ export class LocalMark {
     }
 
     async list(filter?: LocalMarkFilter) : Promise<QueryNameData[]> {
+      if (filter && filter.tags) filter.tags = filter.tags.filter(v => v !== '' && v);
+
       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) {
+
+        if (filter?.tags && filter.tags.length > 0) {
+          if (!obj.tags || obj.tags.length === 0) return false;
+
           for (let i = 0; i < filter.tags.length; ++ i) {
-            if (!obj.tags.includes(filter.tags[i])) return false;
+            if (!obj.tags.includes(filter.tags[i])) {
+              return false
+            }
           }
         }
         return true;

package/src/query/objects.ts

@@ -7,6 +7,7 @@ import { Protocol, Machine_Node, Machine, Treasury_WithdrawMode, Treasury_Operat
     Repository_Type, Repository_Policy_Mode, Repository_Policy, Service_Discount_Type, Service_Sale,
     Progress, History, ERROR, Errors, IsValidAddress, Bcs, Entity_Info, Tags, uint2address} from 'wowok';
 import { CacheExpireType, CacheName, CachedData, Cache } from '../local/cache.js'
+import { LocalMark } from '../local/local.js';
 
 export type ObjectBaseType = 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' | 'Discount' |
         'Personal' | 'Permission' | 'PersonalMark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
@@ -303,6 +304,7 @@ 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[] = [];
+    query.objects = await LocalMark.Instance().get_many_address2(query.objects);
 
     if (!query.no_cache) { // showType only, use cache
         for (let i = 0; i < query.objects.length; ++i) {
@@ -343,9 +345,11 @@ export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer
 }
 
 export const query_personal = async (query:PersonalQuery) : Promise<ObjectPersonal | undefined> => {
-    if (!IsValidAddress(query.address))  {
-        ERROR(Errors.IsValidAddress, 'query_personal.query.address')
+    const addr = await LocalMark.Instance().get_address(query.address);
+    if (!addr)  {
+        ERROR(Errors.InvalidParam, 'query_personal.query.address')
     }
+    query.address = addr;
 
     if (!query.no_cache) {
         try {
@@ -365,9 +369,11 @@ export const query_personal = async (query:PersonalQuery) : Promise<ObjectPerson
 }
 
 export const query_table = async (query:TableQuery) : Promise<TableAnswer> => {
-    if (!IsValidAddress(query.parent))  {
-        ERROR(Errors.IsValidAddress, 'query_table.query.parent');
+    const addr = await LocalMark.Instance().get_address(query.parent);
+    if (!addr)  {
+        ERROR(Errors.InvalidParam, 'query_table.query.parent')
     }
+    query.parent = addr;
 
     if (!query.no_cache) {
         try {
@@ -394,9 +400,11 @@ export const query_table = async (query:TableQuery) : Promise<TableAnswer> => {
 }
 
 const tableItem = async (query:TableItemQuery) : Promise<ObjectBase> => {
-    if (!IsValidAddress(query.parent))  {
-        ERROR(Errors.IsValidAddress, 'query_table.query.parent');
+    const addr = await LocalMark.Instance().get_address(query.parent);
+    if (!addr)  {
+        ERROR(Errors.InvalidParam, 'tableItem.query.parent')
     }
+    query.parent = addr;
 
     if (!query.no_cache) {
         try {