wowok_agent 1.5.13 → 1.5.14

package/src/call/guard.ts

@@ -6,6 +6,7 @@
 import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, 
     concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead,
     IsValidDesription, PassportObject, IsValidGuardIdentifier, GuardQuery, BCS,
+    MODULES,
     } from "wowok";
 import { CallBase, CallResult, Namedbject } from "./base.js";
 import { LocalMark } from "../local/local.js";
@@ -17,9 +18,14 @@ export interface GuardConst {
     value?: any; // if bWitness true, value ignores; otherwise, data.
 }
 
+interface FunctiionQuery {
+    module:MODULES, 
+    function:string,
+}
+
 // parameters: Child nodes arranged in parameter order, with each child node providing the type and data for that parameter
 export type GuardNode = { identifier: number; } // Data from GuardConst
-    | {query: number, object: string | number; parameters: GuardNode[];} // object: address string or identifier in GuardConst that value_type = ValueType.address
+    | {query: number | FunctiionQuery, object: string | number; parameters: GuardNode[];} // object: address string or identifier in GuardConst that value_type = ValueType.address
     | {logic: OperatorType.TYPE_LOGIC_AS_U256_GREATER | OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL
         | OperatorType.TYPE_LOGIC_AS_U256_LESSER | OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL 
         | OperatorType.TYPE_LOGIC_AS_U256_EQUAL | OperatorType.TYPE_LOGIC_EQUAL | OperatorType.TYPE_LOGIC_HAS_SUBSTRING 
@@ -65,7 +71,7 @@ export class CallGuard extends CallBase {
     
         // check root
         var output : Uint8Array[]= [];
-        buildNode(this.data.root!, ValueType.TYPE_BOOL, this.data?.table ?? [], output);
+        await buildNode(this.data.root!, ValueType.TYPE_BOOL, this.data?.table ?? [], output);
         const bytes = (concatenate(Uint8Array, ...output) as Uint8Array); 
 
         const obj = txb.moveCall({
@@ -83,7 +89,7 @@ export class CallGuard extends CallBase {
                     }) 
                 } else {
                     if (v.value_type === ValueType.TYPE_ADDRESS) {
-                        v.value = await LocalMark.Instance().get_address(v.value);
+                        v.value = await LocalMark.Instance().get_address(v.value); // address or name
                         if (!v.value) { ERROR(Errors.InvalidParam, `CallGuard_Data.data.table address`)}
                     };
                     const tmp = Uint8Array.from(Bcs.getInstance().ser(v.value_type, v.value));
@@ -106,7 +112,7 @@ export class CallGuard extends CallBase {
 
 //export const MAX_CHILD_NODE_COUNT = 6;
 
-const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'variable', table:GuardConst[], output:Uint8Array[]) => {
+const buildNode = async (guard_node:GuardNode, type_required:ValueType | 'number' | 'variable', table:GuardConst[], output:Uint8Array[]) => {
     const node: any = guard_node as any;
     if (node?.identifier !== undefined) {
         const f = table.find(v=>v.identifier === node.identifier);
@@ -119,17 +125,18 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
         }
     } else if (node?.query !== undefined) {
         var q: GuardQuery | undefined;
-        if (typeof(node.query) === 'string') {
-            q = GUARD_QUERIES.find(v=>v.query_name === node.query);
-        } else if (typeof(node.query) === 'number') {
+        if (typeof(node.query) === 'number') {
             q = GUARD_QUERIES.find(v=>v.query_id === node.query);
+        } else {
+            q = GUARD_QUERIES.find(v=> v.module === node.query.module && v.query_name === node.query.function);
         }
-        if (!q) ERROR(Errors.InvalidParam, 'query invalid - ' + node?.query);
+
+        if (!q) ERROR(Errors.InvalidParam, `${node.query}  invalid. Its a query number or a struct that module and function name specified`);
         
         checkType(q!.return, type_required, node); // Return type checking
         if (q!.parameters.length === node.parameters.length) {
             for (let i = node.parameters.length - 1; i >= 0; --i) { // stack: first in, last out
-                buildNode(node.parameters[i], q!.parameters[i], table, output); // Recursive check
+                await buildNode(node.parameters[i], q!.parameters[i], table, output); // Recursive check
             }
         } else {
             ERROR(Errors.InvalidParam, 'node query parameters length not match - ' + JSON.stringify(node))
@@ -137,11 +144,12 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
 
         output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_QUERY)); // QUERY TYPE + addr + cmd
         if (typeof(node.object) === 'string') {
-            if (!IsValidAddress(node.object)) {
-                ERROR(Errors.InvalidParam, 'node object from address string - ' + JSON.stringify(node))
+            const object = await LocalMark.Instance().get_address(node.object); // object name or address
+            if (!IsValidAddress(object)) {
+                ERROR(Errors.InvalidParam, 'node object from string - ' + JSON.stringify(node))
             }
             output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ValueType.TYPE_ADDRESS)); 
-            output.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, node.object)); // object address             
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, object)); // object address             
         } else {
             const f = table.find(v=>v.identifier === node.object);
             if (f) {
@@ -157,51 +165,77 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
         checkType(ValueType.TYPE_BOOL, type_required, node); // bool
         switch (node?.logic) {
             case OperatorType.TYPE_LOGIC_AND:
-            case OperatorType.TYPE_LOGIC_OR:
+            case OperatorType.TYPE_LOGIC_OR: {
                 if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node)); 
-                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                const p = (node.parameters as GuardNode[]).reverse();  // reserve
+                for (let i = 0; i < p.length; ++i) {
+                    await buildNode(p[i], ValueType.TYPE_BOOL, table, output);
+                }
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
                 break;
-            case OperatorType.TYPE_LOGIC_NOT:
+            }
+            case OperatorType.TYPE_LOGIC_NOT: {
                 if (node.parameters.length !== 1) ERROR(Errors.InvalidParam, 'node logic parameters length must be 1'+ JSON.stringify(node));
-                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                const p = (node.parameters as GuardNode[]).reverse();
+                for (let i = 0; i < p.length; ++i) {
+                    await buildNode(p[i], ValueType.TYPE_BOOL, table, output);
+                }
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 break;
+            }
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
             case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
             case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
-            case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
+            case OperatorType.TYPE_LOGIC_AS_U256_EQUAL: {
                 if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
-                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, 'number', table, output)); 
+                const p = (node.parameters as GuardNode[]).reverse(); 
+                for (let i = 0; i < p.length; ++i) {
+                    await buildNode(p[i], 'number', table, output);
+                }
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
                 break;
-            case OperatorType.TYPE_LOGIC_EQUAL:
+            }
+            case OperatorType.TYPE_LOGIC_EQUAL: {
                 if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
                 var any_type: any = 'variable';
-                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, any_type, table, output)); 
+                const p = (node.parameters as GuardNode[]).reverse(); 
+                for (let i = 0; i < p.length; ++i) {
+                    await buildNode(p[i], any_type, table, output);
+                }
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
-                break;               
-            case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
+                break;         
+            }      
+            case OperatorType.TYPE_LOGIC_HAS_SUBSTRING: {
                 if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
-                (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_STRING, table, output)); 
+                const p = (node.parameters as GuardNode[]).reverse(); 
+                for (let i = 0; i < p.length; ++i) {
+                    await buildNode(p[i], ValueType.TYPE_STRING, table, output);
+                }
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
                 break;
+            }
         }
     } else if (node?.calc !== undefined) {
         if (node?.calc === OperatorType.TYPE_NUMBER_ADDRESS) {
             checkType(ValueType.TYPE_ADDRESS, type_required, node);
             if (node.parameters.length !== 1) ERROR(Errors.InvalidParam, 'node TYPE_NUMBER_ADDRESS parameters length must == 1'+ JSON.stringify(node));
-            (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, 'number', table, output)); 
+            const p = (node.parameters as GuardNode[]).reverse(); 
+            for (let i = 0; i < p.length; ++i) {
+                await buildNode(p[i], 'number', table, output);
+            }
             output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.calc)); // TYPE 
         } else {
             checkType(ValueType.TYPE_U256, type_required, node);
             if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node calc parameters length must >= 2'+ JSON.stringify(node));
-            (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, 'number', table, output)); 
+            const p = (node.parameters as GuardNode[]).reverse(); 
+            for (let i = 0; i < p.length; ++i) {
+                await buildNode(p[i], 'number', table, output);
+            }
             output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.calc)); // TYPE 
             output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));            
         }
@@ -216,6 +250,12 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
             } else {
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, node.value));
             }
+        } else if (node.value_type === ValueType.TYPE_ADDRESS) {
+            const addr = await LocalMark.Instance().get_address(node.value); // address or name
+            if (!IsValidAddress(addr)) {
+                ERROR(Errors.IsValidAddress, 'node value from string - ' + JSON.stringify(node))
+            }
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, addr));
         } else {
             output.push(Bcs.getInstance().ser(node?.value_type, node.value));            
         }

package/src/call/permission.ts

@@ -104,8 +104,11 @@ export class CallPermission extends CallBase {
                     for (let i = 0; i < this.data.permission.entities.length; ++i) {
                         const v = this.data.permission.entities[i];
                         const addr = await GetAccountOrMark_Address(v.address);
+                        
                         if (addr) {
                             add_entity.push({address:addr, permissions:v.permissions});
+                        } else {
+                            ERROR(Errors.InvalidParam, `CallPermission_Data.data.permission.entities.address ${i}: ${v.address.name_or_address} NOT found `);
                         }
                     }
                     obj?.add_entity(add_entity);

package/src/call/personal.ts

@@ -56,31 +56,25 @@ export class CallPersonal extends CallBase {
         if (obj && obj?.get_object()) {
             switch(this.data.mark.op) {
                 case 'add':
-                    const add  = [];
                     for (let i = 0; i < this.data.mark.data.length; ++i) {
                         const v = this.data.mark.data[i];
                         const addr = await GetAccountOrMark_Address(v.address);
                         if (addr) {
-                            add.push({address:addr, tags:v.tags, name:v.name})
+                            obj?.add(addr, v.tags ?? [], v.name);
+                            //@ always add to local, for easy using
+                            await LocalMark.Instance().put(v.name, {address:addr, tags:v.tags});
                         }
                     }
-
-                    add.forEach(v => {
-                        obj?.add(v.address, v.tags ?? [], v.name)
-                    })
                     break;
                 case 'remove':
-                    const remove = [];
                     for (let i = 0; i < this.data.mark.data.length; ++i) {
                         const v = this.data.mark.data[i];
                         const addr = await GetAccountOrMark_Address(v.address);
                         if (addr) {
-                            remove.push({address:addr, tags:v.tags})
+                            obj?.remove(addr, v.tags ?? []);
+                            //@ dont del from local
                         }
-                    }
-                    remove.forEach(v => {
-                        obj?.remove(v.address, v.tags ?? [])
-                    })                        
+                    }                  
                     break;
                 case 'removeall':
                     for (let i = 0; i < this.data.mark.addresses.length; ++i) {

package/src/local/account.ts

@@ -42,11 +42,11 @@ export class Account {
         }; return Account._instance
     }
     
-    private accountData(data:AccountData | undefined) : AccountData | undefined {
+    private accountData(data:AccountData | undefined, showSecret:boolean=false) : AccountData | undefined {
         if (!data) return ;
         const r = Ed25519Keypair.fromSecretKey(fromHex(data.secret!));
         data.pubkey = r.getPublicKey().toSuiPublicKey();
-        data.secret = undefined; //r.getSecretKey();
+        data.secret = showSecret ? r.getSecretKey() : undefined;
         return data;
     }
 
@@ -192,15 +192,15 @@ export class Account {
         })
     }
 
-    async list(showSuspended?:boolean) : Promise<AccountData[]> {      
+    async list(showSuspended?:boolean, showSecret:boolean=false) : Promise<AccountData[]> {      
         return await retry_db(this.location, async(storage:Level) => {
             const r = await storage.get(AccountKey);
             if (r) {
                 const s = JSON.parse(r) as AccountData[];
                 if (showSuspended) {
-                    return s.map(v => this.accountData(v)!);
+                    return s.map(v => this.accountData(v, showSecret)!);
                 } else {
-                    return s.filter(v => !v.suspended).map(v => this.accountData(v)!);
+                    return s.filter(v => !v.suspended).map(v => this.accountData(v, showSecret)!);
                 }
             }
             return [];

package/src/schema/call.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 import * as WOWOK from 'wowok';
 import * as D from './const.js';
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ObjectUrl } from "./util.js";
+import { GuardQueryModules, ObjectUrl } from "./util.js";
 
 export const GetMarkNameSchema = (object:string='') : z.ZodString=> {
     return z.string().nonempty().describe(D.MarkName_Address_Description(object));
@@ -83,12 +83,17 @@ const ObjectsOperationSchema = (object:string='') => {
     ]) 
 };
 
+export const ModuleSchema = z.enum(GuardQueryModules() as [string, ...string[]]).describe("Modules of the Guard queries");
+
 const GuardNodeSchema: z.ZodType = z.lazy(() => z.union([
     z.object({
         identifier: GuardIndentifierSchema
     }).describe(D.Identifier_Description), 
     z.object({
-        query: z.number().int().describe(D.QueryId_Description),
+        query: z.union([z.number().int().describe(D.QueryId_Description), z.object({
+            module: ModuleSchema,
+            function: z.string().nonempty(),
+        }).describe(D.QueryName_Description)]),
         object: z.union([GetMarkNameSchema(), GuardIndentifierSchema.describe(D.ObjectIdentifier_Description)
         ]).describe(D.ObjectQuery_Description),
         parameters: z.array(GuardNodeSchema).describe(D.GuardNodeParams_Description)

package/src/schema/const.ts

@@ -27,7 +27,7 @@ export const useAddressIfNameExist_Description = `In case of naming conflict: pr
 export const onChain_Description = `If true, the name and tags of the object will be made visible on-chain`;
 export const OnchainDescription_Description = `Description content for newly created on-chain wowok object`
 export const Type_Description = `Generic type for the on-chain object (e.g., specify payment token type '0x2::sui::SUI')`;
-export const ValueType_Description = `Data types of the Wowok protocol:
+export const ValueType_Description = `Data types of the Wowok protocol.
     100: Bool, 101: Address, 102: U8, 103: U64, 104: Vec<U8>, 105: U128,
     106:Vec<Address>, 107: Vec<Bool>, 108: Vec<Vec<U8>>, 
     109:Vec<U64>, 110: Vec<U128>, 111: Option<Address>, 112: Option<Bool>,
@@ -42,7 +42,8 @@ export const Permission_Description = `Operation permissions for the new object
 export const Identifier_Description = `Data from the Guard table corresponding to the identifier`
 export const ObjectIdentifier_Description = 'Object address corresponding to the identifier in the Guard table';
 export const ObjectQuery_Description = 'Object to query';
-export const QueryId_Description = `query ID. SSE: wowok://guard_queries/`;
+export const QueryId_Description = `Guard query by the ID specified`;
+export const QueryName_Description = 'Guard query by the Module and function Name specified';
 export const GuardNodeParams_Description = `Query parameters are sourced from their respective child nodes, with child node return types matching the parameter data types`;
 export const GuardQuery_Description = 'Data from querying the on-chain object'
 export const GuardLogic_Description = `Logical operators for parameters`;

package/src/schema/query.ts

@@ -3,28 +3,10 @@ import { z } from "zod";
 import { GetMarkNameSchema, AccountOrMarkNameSchema } from "./call.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { GUARD_QUERIES, PermissionInfo } from "wowok";
+import { GuardQueryModules, PermissionModules } from "./util.js";
 
 export const QueryWowokProtocolSchemaDescription = `Retrieves the Wowok protocol data`;
 
-const PermissionModules = () : string[] => {
-    const ret : string[] = [];
-    PermissionInfo.forEach(v => {
-        if (!ret.find(i => i === v.module)) {
-            ret.push(v.module);
-        }
-    });
-    return ret;
-}
-const GuardQueryModules = () : string[] => {
-    const ret : string[] = [];
-    GUARD_QUERIES.forEach(v => {
-        if (!ret.find(i => i === v.module)) {
-            ret.push(v.module);
-        }
-    });
-    return ret;
-}
-
 export const BuiltInPermissionSchema = z.object({
     module: z.union([z.array(z.enum(PermissionModules() as [string, ...string[]])).describe("Modules of the built-in permissions"), z.literal('all').describe('All modules')]),
 }).describe("Built-in permissions within the modules of the Wowok protocol");

package/src/schema/util.ts

@@ -96,4 +96,23 @@ export const ObjectOperationResult = (r: CallResult) : string => {
       }
   })
   return JSON.stringify({objects:output, raw_data:r}) 
+}
+
+export const PermissionModules = () : string[] => {
+    const ret : string[] = [];
+    WOWOK.PermissionInfo.forEach(v => {
+        if (!ret.find(i => i === v.module)) {
+            ret.push(v.module);
+        }
+    });
+    return ret;
+}
+export const GuardQueryModules = () : string[] => {
+    const ret : string[] = [];
+    WOWOK.GUARD_QUERIES.forEach(v => {
+        if (!ret.find(i => i === v.module)) {
+            ret.push(v.module);
+        }
+    });
+    return ret;
 }