wowok 1.2.10 → 1.2.12

package/src/passport.ts

@@ -1,11 +1,12 @@
-import { type TransactionObjectInput, Inputs, TransactionObjectArgument} from '@mysten/sui.js/transactions';
-import { SuiObjectResponse } from '@mysten/sui.js/client';
+import { type TransactionObjectInput, Inputs, Transaction as TransactionBlock} from '@mysten/sui/transactions';
+import { SuiObjectResponse } from '@mysten/sui/client';
 import { FnCallType, GuardObject, Protocol, ContextType, OperatorType, Data_Type,
     ValueType, SER_VALUE, IsValidOperatorType } from './protocol';
 import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray,  OPTION_NONE, readOption, readOptionString } from './utils';
 import { BCS, BcsReader } from '@mysten/bcs';
 import { ERROR, Errors } from './exception';
 import { Guard } from './guard';
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
 
 export type Guard_Query_Object = {
     target: FnCallType, // object fnCall
@@ -59,13 +60,11 @@ export interface PassportQuery {
 }
 export class GuardParser {
     protected guard_list: GuardInfo[] = [];
-    protected protocol: Protocol;
     protected guards: string[];
     private index:number = 0;
     private get_index() { return this.index++ }
 
-    private constructor(protocol: Protocol, guards: string[]) { 
-        this.protocol = protocol ;
+    private constructor(guards: string[]) { 
         this.guards = guards;
     }
     guardlist = () => { return this.guard_list }
@@ -453,7 +452,7 @@ export class GuardParser {
 */
     private static  Parse_Guard_Helper(guards: string[], res:SuiObjectResponse[]) {
         const protocol = Protocol.Instance();
-        const me = new GuardParser(protocol, guards);
+        const me = new GuardParser(guards);
         res.forEach((r) => {
             let c = r.data?.content as any;
             if (!c) return;
@@ -512,7 +511,7 @@ export class GuardParser {
 
     parse_constant = (info:GuardInfo, constants:any)  => {
         constants.forEach((v:any) => {
-            if (v.type == (this.protocol.Package() + '::guard::Constant')) {
+            if (v.type == (Protocol.Instance().Package() + '::guard::Constant')) {
                 // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for querying
                 if (v.fields.type == ContextType.TYPE_WITNESS_ID || v.fields.type == ValueType.TYPE_ADDRESS) {
                     info.constant.push({identifier:v.fields.identifier,  index:this.get_index(), type:v.fields.type,
@@ -643,7 +642,7 @@ export class GuardParser {
         })
 
         if (onPassportQueryReady) {
-            this.protocol.Query_Raw(array_unique(objects), {showType:true}).then((res) => {
+            Protocol.Instance().Query_Raw(array_unique(objects), {showType:true}).then((res) => {
                 onPassportQueryReady(this.done_helper(res));
             }).catch(e => {
                 console.log(e);
@@ -651,7 +650,7 @@ export class GuardParser {
             })
             return undefined;
         } else {
-            const res = await this.protocol.Query_Raw(array_unique(objects), {showType:true});
+            const res = await Protocol.Instance().Query_Raw(array_unique(objects), {showType:true});
             return this.done_helper(res);
         }
     }
@@ -686,9 +685,9 @@ export class GuardParser {
 
     // create onchain query for objects : object, movecall-types, id
     private object_query = (data: any, method:'guard_query'|'witness'='guard_query') : Guard_Query_Object | undefined=> {
-        for (let k = 0; k < this.protocol.WOWOK_OBJECTS_TYPE().length; k++) {
-            if (data.type.includes(this.protocol.WOWOK_OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
-                return  { target:this.protocol.WOWOK_OBJECTS_PREFIX_TYPE()[k] + method as FnCallType,
+        for (let k = 0; k < Protocol.Instance().WOWOK_OBJECTS_TYPE().length; k++) {
+            if (data.type.includes(Protocol.Instance().WOWOK_OBJECTS_TYPE()[k]) ) { // type: pack::m::Object<...>
+                return  { target:Protocol.Instance().WOWOK_OBJECTS_PREFIX_TYPE()[k] + method as FnCallType,
                     object:Inputs.SharedObjectRef({
                         objectId: data.objectId,
                         mutable: false,
@@ -705,71 +704,68 @@ export class GuardParser {
 export class Passport {
     static MAX_GUARD_COUNT = 8;
     protected passport;
-    protected protocol;
+    protected txb;
 
     get_object () { return this.passport }
     // return passport object used
     // bObject(true) in cmd env; (false) in service env
-    constructor (protocol:Protocol, query:PassportQuery, bObject:boolean=false)  {
+    constructor (txb:TransactionBlock, query:PassportQuery, bObject:boolean=false)  {
         if (!query.guard || query.guard.length > Passport.MAX_GUARD_COUNT)   {
             ERROR(Errors.InvalidParam, 'guards' )
         }
 
-        this.protocol = protocol;
-        let txb = protocol.CurrentSession();
-        this.passport = txb.moveCall({
-            target: protocol.PassportFn('new') as FnCallType,
+        this.txb = txb;
+        this.passport = this.txb.moveCall({
+            target:Protocol.Instance().PassportFn('new') as FnCallType,
             arguments: []
         });
 
         // add others guards, if any
         query.guard.forEach((g) => {
-            txb.moveCall({
-                target:protocol.PassportFn('guard_add') as FnCallType,
-                arguments:[this.passport, txb.object(g)]
+            this.txb.moveCall({
+                target:Protocol.Instance().PassportFn('guard_add') as FnCallType,
+                arguments:[this.passport, this.txb.object(g)]
             });        
         })
 
         // witness
         query?.witness.forEach((w) => {
-            txb.moveCall({
+            this.txb.moveCall({
                 target: w.target as FnCallType,
-                arguments: [this.passport, txb.object(w.object)],
+                arguments: [this.passport, this.txb.object(w.object)],
                 typeArguments: w.types,
             })
         })
 
+        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         // rules: 'verify' & 'query' in turns; 'verify' at final end.
         query?.query.forEach((q) => {
-            let address = txb.moveCall({
-                target: protocol.PassportFn('passport_verify') as FnCallType,
-                arguments: [ this.passport, txb.object(Protocol.CLOCK_OBJECT)]
+            let address = this.txb.moveCall({
+                target: Protocol.Instance().PassportFn('passport_verify') as FnCallType,
+                arguments: [ this.passport, this.txb.object(clock)]
             }); 
-            txb.moveCall({
+            this.txb.moveCall({
                 target: q.target as FnCallType,
-                arguments: [ bObject ? txb.object(q.object) : txb.object(q.id), this.passport, address ],
+                arguments: [ bObject ? this.txb.object(q.object) : this.txb.object(q.id), this.passport, address ],
                 typeArguments: q.types,
             })
         })
-        
-        txb.moveCall({
-            target: protocol.PassportFn('passport_verify') as FnCallType,
-            arguments: [ this.passport,  txb.object(Protocol.CLOCK_OBJECT) ]
+        this.txb.moveCall({
+            target: Protocol.Instance().PassportFn('passport_verify') as FnCallType,
+            arguments: [ this.passport,  this.txb.object(clock) ]
         });  
     }
     
     destroy() {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target: this.protocol.PassportFn('destroy') as FnCallType,
+        this.txb.moveCall({
+            target: Protocol.Instance().PassportFn('destroy') as FnCallType,
             arguments: [ this.passport ]
         });  
     }
 
     freeze() {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target: this.protocol.PassportFn('freezen') as FnCallType,
+        this.txb.moveCall({
+            target: Protocol.Instance().PassportFn('freezen') as FnCallType,
             arguments: [ this.passport ]
         });  
     }

package/src/permission.ts

@@ -3,6 +3,8 @@ import { FnCallType, TxbObject, PermissionObject, PermissionAddress, GuardObject
 import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUintLarge, Bcs, IsValidName} from './utils';
 import { ERROR, Errors } from './exception';
 import { ValueType } from './protocol';
+import { Passport } from './passport';
+import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
 export enum PermissionIndex {
     repository = 100,
@@ -85,6 +87,19 @@ export interface PermissionInfoType {
     guard?: string;
 }
 
+export interface PermissionAnswer {
+    who: string;
+    owner?: boolean;
+    admin?: boolean;
+    items?: PermissionAnswerItem[]; // items === undefined, while errors
+}
+export interface PermissionAnswerItem {
+    query: PermissionIndexType;
+    permission: boolean;
+    guard?: string;
+}
+export type OnPermissionAnswer = (answer: PermissionAnswer) => void;
+
 export const PermissionInfo : PermissionInfoType[] = [
     {index:PermissionIndex.repository, name:'Repository', description:'Launch new Repository', module: 'repository'},
     {index:PermissionIndex.repository_set_description_set, name:'Description', description:'Set Repository description', module: 'repository'},
@@ -169,46 +184,43 @@ export type Permission_Entity = {
 }
 
 export class  Permission {
-    protected protocol;
+    protected txb;
     protected object : TxbObject;
     
     get_object()  { return this.object }
-    private constructor(protocol:Protocol) {
-        this.protocol = protocol;
+    private constructor(txb:TransactionBlock) {
+        this.txb = txb;
         this.object = '';
     }
-    static From(protocol:Protocol, object:TxbObject) : Permission {
-        let p =  new Permission(protocol);
-        p.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
+    static From(txb:TransactionBlock, object:TxbObject) : Permission {
+        let p =  new Permission(txb);
+        p.object = Protocol.TXB_OBJECT(txb, object);
         return p
     }
 
-    static New(protocol:Protocol, description:string) : Permission {
+    static New(txb:TransactionBlock, description:string) : Permission {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        let p = new Permission(protocol);
-        let txb = protocol.CurrentSession();
+        let p = new Permission(txb);
         p.object = txb.moveCall({
-            target: protocol.PermissionFn('new') as FnCallType,
-            arguments: [txb.pure(description)]
+            target: Protocol.Instance().PermissionFn('new') as FnCallType,
+            arguments: [txb.pure.string(description)]
         });
         return p
     }
 
     launch() : PermissionAddress {
-        let txb = this.protocol.CurrentSession();
-        return txb.moveCall({ // address returned
-            target:this.protocol.PermissionFn('create')  as FnCallType,
-            arguments:[ Protocol.TXB_OBJECT(txb, this.object) ]        
+        return this.txb.moveCall({ // address returned
+            target:Protocol.Instance().PermissionFn('create')  as FnCallType,
+            arguments:[ Protocol.TXB_OBJECT(this.txb, this.object) ]        
         })
     }
 
     destroy()  {
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('destroy') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(txb, this.object)],
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('destroy') as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],
         })  
     }
     add_userdefine(index: number, name:string) {
@@ -219,10 +231,9 @@ export class  Permission {
         if (!IsValidName(name)) {
             ERROR(Errors.IsValidName, 'add_userdefine');
         }
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('user_define_add') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64), txb.pure(name)]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('user_define_add') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(index), this.txb.pure.string(name)]
         })   
     }
     
@@ -231,10 +242,9 @@ export class  Permission {
             ERROR(Errors.IsValidUserDefinedIndex, 'add_userdefine');
         }
 
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('user_define_remove') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64)]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('user_define_remove') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(index)]
         })   
     }
 
@@ -242,11 +252,11 @@ export class  Permission {
         if (!IsValidAddress(old_entity) || !IsValidAddress(new_entity)) {
             ERROR(Errors.IsValidAddress, 'change_entity')
         }
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('change_entity') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_entity, BCS.ADDRESS), 
-                txb.pure(new_entity, BCS.ADDRESS) ]
+
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('change_entity') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(old_entity), 
+                this.txb.pure.address(new_entity) ]
         })     
     }
 
@@ -257,17 +267,16 @@ export class  Permission {
             ERROR(Errors.IsValidArray, 'add_entity2');
         }
 
-        let txb = this.protocol.CurrentSession();
         if (index) {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('add_with_index') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64),
-                    txb.pure(array_unique(entities), 'vector<address>')]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('add_with_index') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.u64(index),
+                    this.txb.pure.vector('address', array_unique(entities))]
             })       
         } else {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('add') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(entities), 'vector<address>')]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('add') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', array_unique(entities))]
             })                   
         }
     }
@@ -289,9 +298,7 @@ export class  Permission {
             ERROR(Errors.InvalidParam, 'entities');
         }
 
-        let txb = this.protocol.CurrentSession();
         let guards:any[]  = [];
-
         for (let i = 0; i < entities.length; i++) {
             let entity = entities[i];
             let indexes :number[] = [];
@@ -310,19 +317,19 @@ export class  Permission {
                 }      
             }    
             //if (indexes.length > 0) {
-                txb.moveCall({
-                    target:this.protocol.PermissionFn('add_batch') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity.entity_address, BCS.ADDRESS), 
-                        txb.pure(indexes, 'vector<u64>')]
+                this.txb.moveCall({
+                    target:Protocol.Instance().PermissionFn('add_batch') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity.entity_address), 
+                        this.txb.pure.vector('u64', indexes)]
                 })            
             //}
         } 
         // set guards
         guards.forEach(({entity_address, index, guard}) => {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('guard_set') as FnCallType,
-                arguments:[ Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
-                    txb.pure(index, BCS.U64), Protocol.TXB_OBJECT(txb, guard)]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('guard_set') as FnCallType,
+                arguments:[ Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(entity_address, BCS.ADDRESS), 
+                    this.txb.pure.u64(index), Protocol.TXB_OBJECT(this.txb, guard)]
             })
         })
     }
@@ -336,18 +343,17 @@ export class  Permission {
             ERROR(Errors.IsValidPermissionIndex, 'index')
         }
 
-        let txb = this.protocol.CurrentSession();
         if (guard) {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('guard_set') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
-                    txb.pure(index, BCS.U64), Protocol.TXB_OBJECT(txb, guard)]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('guard_set') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity_address), 
+                    this.txb.pure.u64(index), Protocol.TXB_OBJECT(this.txb, guard)]
             })    
         } else {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('guard_none') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
-                    txb.pure(index, BCS.U64)]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('guard_none') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity_address), 
+                    this.txb.pure.u64(index)]
             })       
         };
     }
@@ -360,11 +366,10 @@ export class  Permission {
             ERROR(Errors.InvalidParam, 'index')
         }
 
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('remove_index') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
-                txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, array_unique(index)))]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('remove_index') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity_address), 
+                this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, array_unique(index)))]
         })            
     }
     remove_entity(entity_address:string[])  {
@@ -372,21 +377,20 @@ export class  Permission {
             ERROR(Errors.IsValidArray)
         }
 
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('remove') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(entity_address), 'vector<address>')]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('remove') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', array_unique(entity_address))]
         })           
-        ;
     }
+
     set_description(description:string)  {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('description_set') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(txb, this.object), txb.pure(description)]
+
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('description_set') as FnCallType,
+            arguments: [Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description)]
         })
         ;
     }
@@ -396,12 +400,10 @@ export class  Permission {
             ERROR(Errors.IsValidArray)
         }
 
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('admin_add_batch')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(admin), 'vector<address>')]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('admin_add_batch')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address',  array_unique(admin))]
         });           
-        ;
     }
 
     remove_admin(admin:string[], removeall?:boolean)  {
@@ -410,16 +412,15 @@ export class  Permission {
             ERROR(Errors.IsValidArray, 'admin')
         }
 
-        let txb = this.protocol.CurrentSession();
         if (removeall) {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('admins_clear')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object)]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('admins_clear')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
             });    
         } else if (admin) {
-            txb.moveCall({
-                target:this.protocol.PermissionFn('admin_remove_batch')  as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(admin), 'vector<address>')]
+            this.txb.moveCall({
+                target:Protocol.Instance().PermissionFn('admin_remove_batch')  as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('address', array_unique(admin))]
             });            
         }
         
@@ -430,17 +431,84 @@ export class  Permission {
             ERROR(Errors.IsValidAddress)
         }
 
-        let txb = this.protocol.CurrentSession();
-        txb.moveCall({
-            target:this.protocol.PermissionFn('builder_set')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(new_owner, BCS.ADDRESS)]
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('builder_set')  as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(new_owner)]
         });        
     }
+    query_permissions(address_queried:string, permissions:PermissionIndexType[]) {
+        if (!IsValidAddress(address_queried)) {
+            ERROR(Errors.InvalidParam, 'query_permissions');
+        }
+
+        if (permissions.length === 0 || permissions.length > Permission.MAX_QUERY_COUNT) {
+            ERROR(Errors.InvalidParam, 'permissions count');
+        }
+
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('query_permissions') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(address_queried), this.txb.pure.vector('u64', permissions)]
+        })   
+    }
+
+    QueryPermissions(txb:TransactionBlock, address_queried:string, permissions:PermissionIndexType[], onPermissionAnswer:OnPermissionAnswer, sender?:string) {
+        this.query_permissions(address_queried, permissions);
+        Protocol.Client().devInspectTransactionBlock({sender:sender ?? address_queried, transactionBlock:txb}).then((res) => {
+            if (res.results && res.results[0].returnValues && res.results[0].returnValues.length !== 3 )  {
+                onPermissionAnswer({who:address_queried});
+                return 
+            }
+
+            const perm = Bcs.getInstance().de(BCS.U8, Uint8Array.from((res.results as any)[0].returnValues[0][0]));
+
+            if (perm === Permission.PERMISSION_ADMIN || perm === Permission.PERMISSION_OWNER_AND_ADMIN) {
+                onPermissionAnswer({who:address_queried, admin:true, owner:perm%2===1, items:[]})
+            } else {
+                const perms = Bcs.getInstance().de('vector<u8>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
+                const guards = Bcs.getInstance().de('vector<address>', Uint8Array.from((res.results as any)[0].returnValues[2][0]));
+                if (perms.length !== permissions.length) {
+                    onPermissionAnswer({who:address_queried});
+                    return
+                }
+
+                const items: PermissionAnswerItem[] = permissions.map((v, index) => {
+                    const p = perms[index] === Permission.PERMISSION_QUERY_NONE ? false : true;
+                    let g : any = undefined;
+                    if (p && perms[index] < guards.length) {
+                        g = '0x' + guards[perms[index] as number];
+                    }
+                    return {query:v, permission:p, guard:g} 
+                })
+                onPermissionAnswer({who:address_queried, admin:false, owner:perm%2===1, items:items});
+            }
+        }).catch((e) => {
+            console.log(e);
+            onPermissionAnswer({who:address_queried});
+        })
+    }
+    static HasPermission(answer:PermissionAnswer|undefined, index:PermissionIndexType) : {has:boolean, guard?:string, owner?:boolean} {
+        if (answer) {
+            if (answer.admin) return {has:true, owner:answer.owner}; // admin
+            let i = answer.items?.find((v)=>v.query === index);
+            if (i) {
+                return {has:i.permission, guard:i.guard, owner:answer.owner};
+            }          
+        }
+        return {has:false}
+    }
 
     static MAX_ADMIN_COUNT = 64;
     static MAX_ENTITY_COUNT = 2000;
     static MAX_PERMISSION_INDEX_COUNT = 200;
     static MAX_PERSONAL_PERMISSION_COUNT = 200; 
+    static MAX_QUERY_COUNT = 250; // 
+    static PERMISSION_QUERY_NONE = 255;
+    static PERMISSION_QUERY_HAS = 254;
+    static PERMISSION_NORMAL = 0;
+    static PERMISSION_OWNER = 1;
+    static PERMISSION_ADMIN = 2;
+    static PERMISSION_OWNER_AND_ADMIN = 3;
+
     static IsValidUserDefinedIndex = (index:number)  => { 
         return index >= PermissionIndex.user_defined_start && IsValidUintLarge(index)
     }