wowok 1.2.12 → 1.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.2.12",
+  "version": "1.3.4",
   "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

@@ -1,5 +1,4 @@
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { BCS } from '@mysten/bcs';
 import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject, ResourceObject} from './protocol';
 import { IsValidDesription, IsValidUintLarge, IsValidAddress, IsValidArgType, } from './utils'
 import { Errors, ERROR}  from './exception'

package/src/entity.ts

@@ -1,4 +1,3 @@
-import { BCS, encodeStr, getSuiMoveConfig } from '@mysten/bcs';
 import { Protocol, FnCallType, TxbObject, ResourceAddress, PermissionObject, ResourceObject} from './protocol';
 import { IsValidDesription, IsValidAddress, IsValidName, isValidHttpUrl, Bcs,  } from './utils';
 import { ERROR, Errors } from './exception';

package/src/exception.ts

@@ -9,6 +9,7 @@ export enum Errors {
     IsValidTokenType = 'invalid token type',
     IsValidUint = 'invalid uint',
     IsValidInt = 'invalid int', 
+    IsValidU64 = 'invalid u64',
     IsValidPercent = 'invalid percent',
     IsValidArray = 'invalid array',
     IsValidObjects = 'invalid objects',

package/src/guard.ts

@@ -1,5 +1,5 @@
 
-import { BCS } from '@mysten/bcs';
+
 import { Protocol, LogicsInfo, GuardAddress, FnCallType, Data_Type, MODULES, ContextType, ValueType,  OperatorType, ConstantType, SER_VALUE} from './protocol';
 import { concatenate, array_equal } from './utils';
 import { IsValidDesription, Bcs, IsValidInt, IsValidAddress, FirstLetterUppercase } from './utils';

package/src/machine.ts

@@ -1,9 +1,9 @@
 import { Transaction as TransactionBlock, TransactionObjectArgument, type TransactionResult } from '@mysten/sui/transactions';
-import { BCS } from '@mysten/bcs';
 import { Protocol, FnCallType, PermissionObject, RepositoryObject,  PassportObject, MachineObject, MachineAddress,  GuardObject, TxbObject} from './protocol';
 import { IsValidInt, Bcs, array_unique, IsValidArray, IsValidAddress, IsValidName, IsValidName_AllowEmpty, 
     IsValidEndpoint, IsValidDesription,
-    IsValidUintLarge} from './utils'
+    IsValidUintLarge,
+    IsValidU64} from './utils'
 import { Permission, PermissionIndexType } from './permission';
 import { Errors, ERROR}  from './exception'
 import { ValueType } from './protocol';
@@ -26,6 +26,14 @@ export interface Machine_Node {
     pairs: Machine_Node_Pair[];
 }
 
+export interface QueryGuardParam {
+    node: string;
+    prior_node: string;
+    forward: string;
+    txb: TransactionBlock;
+    guard: string | null;
+}
+export type OnQueryGuard = (param: QueryGuardParam) => void;
 export class Machine {
     protected txb;
     protected object : TxbObject;
@@ -83,7 +91,7 @@ export class Machine {
                 if (!IsValidName_AllowEmpty(p.prior_node)) { bValid = false; }
                 if (p?.threshold && !IsValidInt(p.threshold)) { bValid = false; }
                 p.forwards.forEach((f) => {
-                    if (!Machine.isValidForward(f)) bValid = false;
+                    if (Machine.checkValidForward(f) !== '') bValid = false;
                 })
             })
         })
@@ -120,21 +128,30 @@ export class Machine {
 
     forward(forward:Machine_Forward) : TransactionResult {
         let weight = forward?.weight ? forward.weight : 1;
-        let perm = this.txb.pure.option('u64', forward?.permission); 
-        let namedOperator = forward?.namedOperator ?  this.txb.pure.string(forward.namedOperator) : this.txb.pure.string('');
         let f:any;
 
-        if (forward?.guard) {
+        // namedOperator first.
+        if (forward?.namedOperator && IsValidName(forward.namedOperator)) {
+            if (forward?.guard) {
+                f = this.txb.moveCall({ 
+                    target:Protocol.Instance().MachineFn('forward') as FnCallType,
+                        arguments:[this.txb.pure.string(forward.namedOperator), this.txb.pure.u16(weight), this.txb.object(Protocol.TXB_OBJECT(this.txb, forward.guard))]
+                });                        
+            } else {
+                f = this.txb.moveCall({ 
+                    target:Protocol.Instance().MachineFn('forward2') as FnCallType,
+                        arguments:[this.txb.pure.string(forward.namedOperator), this.txb.pure.u16(weight)]
+                });                
+            }            
+        } else if (forward?.permission !== undefined && IsValidU64(forward.permission)) {
             f = this.txb.moveCall({ 
-                target:Protocol.Instance().MachineFn('forward') as FnCallType,
-                    arguments:[namedOperator, this.txb.pure.u16(weight), this.txb.object(Protocol.TXB_OBJECT(this.txb, forward.guard)), perm]
-            });                        
+                target:Protocol.Instance().MachineFn('forward3') as FnCallType,
+                    arguments:[this.txb.pure.u64(forward.permission), this.txb.pure.u16(weight)]
+            });    
         } else {
-            f = this.txb.moveCall({ 
-                target:Protocol.Instance().MachineFn('forward2') as FnCallType,
-                    arguments:[namedOperator, this.txb.pure.u16(weight), perm]
-            });                
+            ERROR(Errors.InvalidParam, 'forward')
         }
+
         return f
     }
 
@@ -206,13 +223,13 @@ export class Machine {
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().MachineFn('node_remove_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), 
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure.vector('string', nodes_name), 
                     this.txb.pure.bool(bTransferMyself), Protocol.TXB_OBJECT(this.txb, this.permission)],
             });  
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().MachineFn('node_remove') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), 
+                arguments:[Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure.vector('string', nodes_name), 
                     this.txb.pure.bool(bTransferMyself), Protocol.TXB_OBJECT(this.txb, this.permission)],
             });
         } 
@@ -373,10 +390,10 @@ export class Machine {
         this.permission = new_permission;   
     }
 
-    add_forward(node_prior:string, node_name:string, foward: Machine_Forward, threshold?:number, passport?:PassportObject) {
+    add_forward(node_prior:string, node_name:string, foward: Machine_Forward, threshold?:number, old_forward_name?:string, passport?:PassportObject) {
         if (!IsValidName_AllowEmpty(node_prior)) ERROR(Errors.IsValidName_AllowEmpty, 'add_forward');
         if (!IsValidName(node_name)) ERROR(Errors.IsValidName, 'add_forward');
-        if (!Machine.isValidForward(foward)) ERROR(Errors.InvalidParam, 'add_forward');
+        const err = Machine.checkValidForward(foward); if (err) ERROR(Errors.InvalidParam, err);
 
         let n : any;
         if (passport) {
@@ -397,6 +414,14 @@ export class Machine {
             target:Protocol.Instance().MachineFn('forward_add') as FnCallType,
             arguments:[n, this.txb.pure.string(node_prior), this.txb.pure.string(foward.name), t, f],
         })
+        
+        if (old_forward_name && old_forward_name !== foward.name) {
+            this.txb.moveCall({
+                target:Protocol.Instance().MachineFn('forward_remove') as FnCallType,
+                arguments:[n, this.txb.pure.string(node_prior), this.txb.pure.string(old_forward_name)],
+            })
+        }
+        this.add_node2([n], passport);
     }
 
     remove_forward(node_prior:string, node_name:string, foward_name: string, passport?:PassportObject) {
@@ -420,6 +445,7 @@ export class Machine {
             target:Protocol.Instance().MachineFn('forward_remove') as FnCallType,
             arguments:[n, this.txb.pure.string(node_prior), this.txb.pure.string(foward_name)],
         })
+        this.add_node2([n], passport);
     }
 
     static rpc_de_nodes(fields: any) : Machine_Node[] {
@@ -458,15 +484,37 @@ export class Machine {
         return ret;
     }
 
-    static isValidForward(forward:Machine_Forward) {
-        if (!IsValidName(forward.name)) return false
-        if (forward?.namedOperator && !IsValidName_AllowEmpty(forward?.namedOperator)) return false;
-        if (forward?.permission && !Permission.IsValidPermissionIndex(forward?.permission)) return false;
-        if (!forward?.permission && !forward?.namedOperator) return false;
-        if (forward?.weight && !IsValidUintLarge(forward.weight)) return false;
-        return true
+    static checkValidForward(forward:Machine_Forward) : string {
+        if (!IsValidName(forward.name)) return 'Forward name invalid'
+        if (forward?.namedOperator && !IsValidName_AllowEmpty(forward?.namedOperator)) return 'Progress Operator invalid';
+        if (forward?.permission && !Permission.IsValidPermissionIndex(forward?.permission)) return 'Permission index invalid';
+        if (!forward?.permission && !forward?.namedOperator) return 'Both Permission index and Progress Operator empty';
+        if (forward?.weight && !IsValidUintLarge(forward.weight)) return 'Weight invalid';
+        return ''
     }
 
+
+    QueryForwardGuard(sender:string, node:string, prior_node:string, forward:string, onGuard:OnQueryGuard) {
+        if (!node || !forward) { // prior_node maybe ''
+            ERROR(Errors.InvalidParam, 'QueryForwardGuard');
+            return ;
+        }
+
+        this.txb.moveCall({
+            target:Protocol.Instance().MachineFn('query_guard') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(node), 
+                this.txb.pure.string(prior_node), this.txb.pure.string(forward)],
+        });
+
+        Protocol.Client().devInspectTransactionBlock({sender:sender, transactionBlock:this.txb}).then((res) => {
+            if (res.results?.length === 1 && res.results[0].returnValues?.length === 1) {
+                const guard = Bcs.getInstance().de('Option<address>', Uint8Array.from(res.results[0].returnValues[0][0]));
+                onGuard({node:node, prior_node:prior_node, forward:forward, guard:guard?.some?('0x'+guard?.some):'', txb:this.txb});
+            }
+        }).catch(e=>{
+            console.log(e);
+        })
+    }
     static INITIAL_NODE_NAME = '';
 /*    static NODE_NAME_RESERVED = 'origin';
     static IsNodeNameReserved = (name:string) => { 

package/src/passport.ts

@@ -3,10 +3,8 @@ 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
@@ -480,11 +478,15 @@ export class GuardParser {
 
         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); })            
+                .then((res) => { 
+                    onGuardInfo(GuardParser.Parse_Guard_Helper(guards, res)); 
+                }).catch((e) => { 
+                    console.log(e);
+                    onGuardInfo(undefined); 
+                })            
         } else {
             const res = await protocol.Query_Raw(guard_list);
             return GuardParser.Parse_Guard_Helper(guards, res);
@@ -640,7 +642,6 @@ export class GuardParser {
                 objects.push(this.get_object(g.id, q, fill));
             })
         })
-
         if (onPassportQueryReady) {
             Protocol.Instance().Query_Raw(array_unique(objects), {showType:true}).then((res) => {
                 onPassportQueryReady(this.done_helper(res));
@@ -769,6 +770,51 @@ export class Passport {
             arguments: [ this.passport ]
         });  
     }
+
+    query_result(sender:string, handleResult:OnQueryPassportResult) {
+        this.txb.moveCall({
+            target: Protocol.Instance().PassportFn('query_result') as FnCallType,
+            arguments: [ this.passport ]
+        });  
+
+        Protocol.Client().devInspectTransactionBlock({sender:sender, transactionBlock:this.txb}).then((res) => {
+            const r = Passport.ResolveQueryRes(this.txb, res);
+            if (r) handleResult(r);
+        }).catch(e=>{
+            console.log(e);
+        })
+    }
+
+    query_result_async = async (sender:string) : Promise<QueryPassportResult | undefined> => {
+        this.txb.moveCall({
+            target: Protocol.Instance().PassportFn('query_result') as FnCallType,
+            arguments: [ this.passport ]
+        });  
+
+        const res = await Protocol.Client().devInspectTransactionBlock({sender:sender, transactionBlock:this.txb});
+        return Passport.ResolveQueryRes(this.txb, res);
+    }
+
+    private static  ResolveQueryRes(txb:TransactionBlock, res:any) : QueryPassportResult | undefined {
+        for (let i = 0; i < res.results?.length; ++ i) {
+            const v = res.results[i];
+            if (v?.returnValues && v.returnValues.length === 2 && 
+                v.returnValues[0][1] === 'bool' && v.returnValues[1][1] === 'vector<address>') { // (bool, vector<address>)
+                const result = Bcs.getInstance().de('bool', Uint8Array.from(v.returnValues[0][0]));
+                const guards = Bcs.getInstance().de('vector<address>', Uint8Array.from(v.returnValues[1][0])).map((v:string)=>'0x'+v);
+                return {txb:txb, result:result, guards:guards}
+            }
+        }
+        return undefined
+    }
 }
 
+export interface QueryPassportResult {
+    txb: TransactionBlock;
+    result: boolean;
+    guards: string[];
+}
+
+export type OnQueryPassportResult = (result:QueryPassportResult) => void;
+