wowok 1.2.9 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "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/demand.ts

@@ -19,7 +19,7 @@ export class Demand {
         let d = new Demand(protocol,  bounty_type, permission)
         d.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object)
         return d
-    }
+    }   
 
     private constructor(protocol:Protocol, bounty_type:string, permission:PermissionObject) {
         this.bounty_type = bounty_type;

package/src/entity.ts

@@ -97,7 +97,7 @@ export class Entity {
     }
 
     query_ent(address_queried:string) {
-        if (!address_queried) {
+        if (!IsValidAddress(address_queried)) {
             ERROR(Errors.InvalidParam, 'query_ent');
         }
 

package/src/passport.ts

@@ -1,4 +1,5 @@
-import { type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
+import { type TransactionObjectInput, Inputs, TransactionObjectArgument} from '@mysten/sui.js/transactions';
+import { SuiObjectResponse } from '@mysten/sui.js/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';
@@ -8,7 +9,7 @@ import { Guard } from './guard';
 
 export type Guard_Query_Object = {
     target: FnCallType, // object fnCall
-    object: TransactionObjectInput, // object 
+    object: TransactionObjectInput | string, // object 
     types: string[], // object type
     id: string, // object id
 }
@@ -19,9 +20,11 @@ export interface QueryInfo {
     type: number;
     value_or_witness: string;
     future?: string;
+    cmd?: number;
 }
 interface GuardInfo {
-    id: string;
+    id: string; // guard id
+    object: TransactionObjectInput;
     query_list: (string | QueryInfo)[]; // object or witness object query
     constant: QueryInfo[]; // witness in constant & ValueType.TYPE_ADDRESS(for Query)
     input_witness: QueryInfo[]; // witness in input
@@ -41,26 +44,29 @@ export interface DeGuardData {
     ret_type?: number;
 }
 
-export interface FutrueFill {
+export interface FutureFill {
     guard: string;
     index: number;
-    future: string;
+    witness: string;
+    future?: string;
+    cmd?: number;
+    type?: string;
 }
 export interface PassportQuery {
-    guard: GuardObject[];
+    guard: (string | TransactionObjectInput)[];
     query: Guard_Query_Object[];
     witness: Guard_Query_Object[];
 }
 export class GuardParser {
     protected guard_list: GuardInfo[] = [];
     protected protocol: Protocol;
-    protected guards: GuardObject[];
+    protected guards: string[];
     private index:number = 0;
     private get_index() { return this.index++ }
 
     private constructor(protocol: Protocol, guards: string[]) { 
         this.protocol = protocol ;
-        this.guards = guards.map(g => protocol.CurrentSession().object(g) as GuardObject);
+        this.guards = guards;
     }
     guardlist = () => { return this.guard_list }
 
@@ -283,6 +289,7 @@ export class GuardParser {
         switch (current.type) {
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
                 current.ret_type = ValueType.TYPE_BOOL;
+                stack.push(current);
                 return;
             case OperatorType.TYPE_LOGIC_NOT:
                 current.ret_type = ValueType.TYPE_BOOL;
@@ -416,7 +423,7 @@ export class GuardParser {
         ERROR(Errors.Fail, 'OperateParamCount: type  invalid ' + current.type);
     }
 
-    /// create GuardParser ayncly
+ /*   
     static CreateAsync = async (protocol: Protocol, guards: string[]) => {
         if (!IsValidArray(guards, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'guards');
@@ -426,6 +433,7 @@ export class GuardParser {
         const me = new GuardParser(protocol, guards);
         
         let res =  await protocol.Query_Raw(guard_list);
+        console.log(res)
         res.forEach((r) => {
             let c = r.data?.content as any;
             if (!c) return;
@@ -442,11 +450,70 @@ export class GuardParser {
         })
         return me
     }
+*/
+    private static  Parse_Guard_Helper(guards: string[], res:SuiObjectResponse[]) {
+        const protocol = Protocol.Instance();
+        const me = new GuardParser(protocol, guards);
+        res.forEach((r) => {
+            let c = r.data?.content as any;
+            if (!c) return;
+
+            let index = protocol.WOWOK_OBJECTS_TYPE().findIndex(v => {return v.includes('guard::Guard') && v == c.type});
+            if (index == -1) return;
+
+            let info:GuardInfo = {id: c.fields.id.id, query_list:[],  constant:[], input_witness:[], object:Inputs.ObjectRef(
+                {objectId:c.fields.id.id, digest:r.data?.digest??'', version:r.data?.version ?? ''}
+            )};
+            me.parse_constant(info,  c.fields.constants); // MUST first
+            if (c.fields.input.type === (protocol.Package() + '::bcs::BCS')) {
+                me.parse_bcs(info,  Uint8Array.from(c.fields.input.fields.bytes)); // second
+            }
+            me.guard_list.push(info);
+        })
+        return me
+    }
+
+    static Create = async (guards: string[], onGuardInfo?:(parser:GuardParser|undefined)=>void) => {
+        if (!IsValidArray(guards, IsValidAddress)) {
+            if (onGuardInfo) onGuardInfo(undefined);
+            return undefined;
+        }
+
+        let guard_list = array_unique(guards);
+        const protocol = Protocol.Instance();
+        
+        if (onGuardInfo) {
+            protocol.Query_Raw(guard_list)
+                .then((res) => { onGuardInfo(GuardParser.Parse_Guard_Helper(guards, res)); })
+                .catch((e) => { onGuardInfo(undefined); })            
+        } else {
+            const res = await protocol.Query_Raw(guard_list);
+            return GuardParser.Parse_Guard_Helper(guards, res);
+        }
+    }
+
+    future_fills = () : FutureFill[] => {
+        const ret : FutureFill[] = [];
+        this.guard_list.forEach((g) => {
+            g.query_list.forEach((v) => {
+                if (typeof(v) !== 'string') {
+                    ret.push({guard:g.id, index:v.index, witness:v.value_or_witness, cmd:v.cmd});
+                }
+            })
+            // cmd already in query_list, so filter it out.
+            g.constant.filter((v)=>v.type === ContextType.TYPE_WITNESS_ID && v.cmd === undefined).forEach((v) => {
+                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
+            })
+            g.input_witness.forEach((v) => {
+                ret.push({guard:g.id, index:v.index, witness:v.value_or_witness});
+            })
+        }); return ret;
+    }
 
     parse_constant = (info:GuardInfo, constants:any)  => {
         constants.forEach((v:any) => {
             if (v.type == (this.protocol.Package() + '::guard::Constant')) {
-                // ValueType.TYPE_ADDRESS: Query_Cmd maybe used the address, so save it for using
+                // 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,
                         value_or_witness:'0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(v.fields.value))});
@@ -507,14 +574,14 @@ export class GuardParser {
                 let type = arr.splice(0, 1);
                 if (type[0] == ValueType.TYPE_ADDRESS || type[0] == ContextType.TYPE_WITNESS_ID) {
                     let addr = '0x' + Bcs.getInstance().de(ValueType.TYPE_ADDRESS, Uint8Array.from(arr)).toString();
-                    arr.splice(0, 33); // address + cmd              
+                    const offset = arr.splice(0, 33); // address + cmd              
                     if (type[0] == ValueType.TYPE_ADDRESS) {
                         info.query_list.push(addr);
                     } else if (type[0] == ContextType.TYPE_WITNESS_ID){
-                        info.query_list.push({index:this.get_index(), type:type[0], value_or_witness:addr});
+                        info.query_list.push({index:this.get_index(), type:type[0], value_or_witness:addr, cmd:offset[offset.length-1]});
                     }
                 } else if (type[0] == ContextType.TYPE_CONSTANT) {
-                    let identifer = arr.splice(0, 2); // key + cmd
+                    const identifer = arr.splice(0, 2); // key + cmd
                     let constant = info.constant.find((v) => 
                         (v.identifier == identifer[0]) && 
                         ((v.type == ValueType.TYPE_ADDRESS) || (v.type == ContextType.TYPE_WITNESS_ID)));
@@ -522,7 +589,11 @@ export class GuardParser {
                     if (constant?.type == ValueType.TYPE_ADDRESS) {
                         info.query_list.push(constant.value_or_witness);
                     } else if (constant?.type == ContextType.TYPE_WITNESS_ID) {
-                        info.query_list.push({identifier:identifer[0], type:constant.type, value_or_witness:constant.value_or_witness, index:this.get_index()});
+                        const index = this.get_index();
+                        info.query_list.push({identifier:identifer[0], type:constant.type, value_or_witness:constant.value_or_witness, 
+                            index:index, cmd:identifer[identifer.length-1]}); // query witness in constant
+                        constant.cmd = identifer[identifer.length-1]; // mark this is a cmd in querylist(avoid multi input future by singer)
+                        constant.index = index;
                     } 
                 } else {
                     ERROR(Errors.Fail, 'constant type invalid');
@@ -535,7 +606,7 @@ export class GuardParser {
         } 
     }
 
-    private get_object(guardid:string, info:QueryInfo, fill?:FutrueFill[]) :  string  {
+    private get_object(guardid:string, info:QueryInfo, fill?:FutureFill[]) :  string  {
         let r = fill?.find(i => guardid == i.guard && i.index == info.index);
         if (!r || !r.future) {
             if (!info.future) {
@@ -547,12 +618,14 @@ export class GuardParser {
         return info.future!
     }
 
-    done = async (fill?:FutrueFill[]) : Promise<PassportQuery>=> {
+    done = async (fill?:FutureFill[], onPassportQueryReady?:(passport:PassportQuery | undefined)=>void) : Promise<PassportQuery | undefined>=> {
         let objects: string[] = [];
         this.guard_list.forEach((g) => {
-            g.constant.filter(v => v.type == ContextType.TYPE_WITNESS_ID).forEach((q) => {
+            // futures in constant table (all witness)
+            g.constant.filter(v => v.type == ContextType.TYPE_WITNESS_ID /*&& v.cmd === undefined*/).forEach((q) => {
                 objects.push(this.get_object(g.id, q, fill));
             })
+            // objects to query
             let list = g.query_list.map((q) => {
                 if (typeof(q) === "string") {
                     objects.push(q)
@@ -563,40 +636,56 @@ export class GuardParser {
                     return r
                 }
             })
-            g.query_list =  list;
+            g.query_list =  list; // all to string to query
             g.input_witness.forEach((q) => {
                 objects.push(this.get_object(g.id, q, fill));
             })
         })
 
-        // objects info
-        let res = await  this.protocol.Query_Raw(array_unique(objects), {showType:true});
+        if (onPassportQueryReady) {
+            this.protocol.Query_Raw(array_unique(objects), {showType:true}).then((res) => {
+                onPassportQueryReady(this.done_helper(res));
+            }).catch(e => {
+                console.log(e);
+                onPassportQueryReady(undefined);
+            })
+            return undefined;
+        } else {
+            const res = await this.protocol.Query_Raw(array_unique(objects), {showType:true});
+            return this.done_helper(res);
+        }
+    }
+
+    private done_helper(res:SuiObjectResponse[]) {
         let query: Guard_Query_Object[] = [];
         let witness: Guard_Query_Object[] = [];
+        let guards: TransactionObjectInput[] = [];
         this.guard_list.forEach(g => {
-            g.query_list.forEach(q => {
+            g.query_list.forEach(q => { // query list
                 let r = res.find(r => r.data?.objectId == q as string);  
                 if (!r)   { ERROR(Errors.Fail, 'query object not match')} 
-                let object = this.object_query(r!.data);
+                let object = this.object_query(r!.data); // build passport query objects
                 if (!object) { ERROR(Errors.Fail, 'query object fail')} 
                 query.push(object!);
             })
-            res.forEach(q => {
-                let r1 = g.constant.find(v  => v.future == q.data?.objectId);
-                let r2 = g.input_witness.find(v  => v.future == q.data?.objectId)
+            res.forEach(q => { // witness(address & query) list
+                let r1 = g.constant.find(v  => v.future === q.data?.objectId);
+                let r2 = g.input_witness.find(v  => v.future === q.data?.objectId)
                 // not match r1 || r2 means query-cmd, not witness-cmd
                 if (r1 || r2) {
-                    let object = this.object_query(q.data, 'witness');
+                    let object = this.object_query(q.data, 'witness'); // witness address onchain check
                     if (!object)  { ERROR(Errors.Fail, 'witness object fail') }
                     witness.push(object!);
                 }
             })
+            guards.push(g.object);
         })
 
-        return {guard:this.guards, query:query,  witness:witness} as PassportQuery;
+        return {guard:guards, query:query,  witness:witness} as PassportQuery;
     }
 
-    private object_query = (data: any, method:string='guard_query') : Guard_Query_Object | undefined=> {
+    // 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,
@@ -620,13 +709,11 @@ export class Passport {
 
     get_object () { return this.passport }
     // return passport object used
-    constructor (protocol:Protocol, query:PassportQuery)  {
+    // bObject(true) in cmd env; (false) in service env
+    constructor (protocol:Protocol, query:PassportQuery, bObject:boolean=false)  {
         if (!query.guard || query.guard.length > Passport.MAX_GUARD_COUNT)   {
             ERROR(Errors.InvalidParam, 'guards' )
         }
-        if (!Protocol.IsValidObjects(query.guard)) {
-            ERROR(Errors.IsValidObjects, 'guards')
-        }
 
         this.protocol = protocol;
         let txb = protocol.CurrentSession();
@@ -639,7 +726,7 @@ export class Passport {
         query.guard.forEach((g) => {
             txb.moveCall({
                 target:protocol.PassportFn('guard_add') as FnCallType,
-                arguments:[this.passport, Protocol.TXB_OBJECT(txb, g)]
+                arguments:[this.passport, txb.object(g)]
             });        
         })
 
@@ -652,7 +739,7 @@ export class Passport {
             })
         })
 
-        // rules: 'verify' & 'query' in turns；'verify' at final end.
+        // rules: 'verify' & 'query' in turns; 'verify' at final end.
         query?.query.forEach((q) => {
             let address = txb.moveCall({
                 target: protocol.PassportFn('passport_verify') as FnCallType,
@@ -660,11 +747,10 @@ export class Passport {
             }); 
             txb.moveCall({
                 target: q.target as FnCallType,
-                arguments: [ txb.object(q.object), this.passport, address ],
+                arguments: [ bObject ? txb.object(q.object) : 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) ]

package/src/permission.ts

@@ -3,6 +3,7 @@ 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';
 
 export enum PermissionIndex {
     repository = 100,
@@ -85,6 +86,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'},
@@ -436,11 +450,81 @@ export class  Permission {
             arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(new_owner, BCS.ADDRESS)]
         });        
     }
+    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');
+        }
+
+        const txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.PermissionFn('query_permissions') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(address_queried, BCS.ADDRESS), txb.pure(permissions, 'vector<u64>')]
+        })   
+    }
+
+    QueryPermissions(address_queried:string, permissions:PermissionIndexType[], onPermissionAnswer:OnPermissionAnswer, sender?:string) {
+        this.query_permissions(address_queried, permissions);
+        Protocol.Client().devInspectTransactionBlock({sender:sender ?? address_queried, 
+            transactionBlock:this.protocol.CurrentSession()}).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)
     }

package/src/protocol.ts

@@ -191,9 +191,9 @@ export enum ENTRYPOINT {
 }
 
 const TESTNET = {
-    package: "0x8ba9f90c9a0e5f2199a92fdc5ea255ac9df5471289cfe40a87ac90f25d93dd5b",
-    wowok_object: '0x9d33a57a09f3ff73ba51afe6ed2e671e7d78b771e34b0a1ba66e52264e34b3fd',
-    entity_object: '0xb759e1e5569f1f8d5ae30efb6efec0a639c5ef70a7c7abcc012919cf5dae33af',
+    package: "0xc5bcb215cb4bc861203739b7378199969d4f60f5e8130fa1ebf87987bdee0b6a",
+    wowok_object: '0xe9fdb9c3ad7aa81ee32d3fc9618d6e69637111253445e864f898d29179d11a4d',
+    entity_object: '0xe1205f43507c943a82d5a67cb7d2b3b251ff4a80f3b38e815a78291ed53125ce',
 }
 
 const MAINNET = {

package/src/utils.ts

@@ -241,7 +241,11 @@ export class Bcs {
         return new Uint8Array();
     }
 
-    de(type:ValueType, data:Uint8Array | any) : any {
+    de(type:ValueType | string,  data:Uint8Array | any) : any {
+        if (typeof(type) === 'string') {
+            return this.bcs.de(type, data);
+        }
+
         switch(type) {
             case ValueType.TYPE_BOOL:
                 return this.bcs.de(BCS.BOOL, data);