wowok 1.0.3 → 1.0.4

package/src/machine.ts

@@ -1,29 +1,27 @@
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS } from '@mysten/bcs';
-import { name_data, CLOCK_OBJECT, PROTOCOL, FnCallType, description_data, MAX_ENDPOINT_LENGTH} from './protocol';
-import { verify,  PassportObject} from './passport'
-import { PermissionIndex, PermissionObject } from './permission'
-import { RepositoryObject } from './repository';
+import { PROTOCOL, FnCallType, PermissionObject, RepositoryObject, IsValidEndpoint, OptionNone, IsValidDesription, PassportObject,
+    TXB_OBJECT, MachineObject, MachineAddress, IsValidArray, IsValidAddress, IsValidName, IsValidName_AllowEmpty, GuardObject, 
+    IsValidInt, IsValidUint, IsValidObjects} from './protocol';
 import { BCS_CONVERT } from './util'
+import { IsValidPermissionIndex, PermissionIndexType } from './permission';
 
 
-export type MachineAddress = TransactionResult;
-export type MachineObject = TransactionResult;
 export type MachineNodeObject = TransactionResult;
 
 export const INITIAL_NODE_NAME = '';
 
 export type Machine_Forward = {
     name: string; // foward name
-    namedOperator?: string; 
-    permission?: number; // permission-index or named-operator MUST one defined.
+    namedOperator?: string; // dynamic operator
+    permission?: PermissionIndexType; // permission-index or named-operator MUST one defined.
     weight?: number;
-    guard_address?: string;
+    guard?: GuardObject;
 }
 export type Machine_Node_Pair = {
     prior_node: string;
-    threshold: number;
     forwards: Machine_Forward[];
+    threshold?: number;
 }
 export type Machine_Node = {
     name: string;
@@ -31,227 +29,274 @@ export type Machine_Node = {
     pairs: Machine_Node_Pair[];
 }
 
-// node & forward & forward permission string length validation
-export function is_valid_name(name:string):boolean { return name.length > 0 && name.length < 33 }
-
 // 创建新的node加入到machine
-export function machine_add_node(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, nodes:Machine_Node[], passport?:PassportObject) {
+export function machine_add_node(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    nodes:Machine_Node[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    let bValid = true;
+    nodes.forEach((node) => {
+        if (!IsValidDesription(node.description) || !IsValidName(node.name))  { bValid = false; }
+
+        node.pairs.forEach((p) => {
+            if (!IsValidName_AllowEmpty(p.prior_node)) { bValid = false; }
+            if (p?.threshold && !IsValidInt(p.threshold)) { bValid = false; }
+            p.forwards.forEach((f) => {
+                if (!IsValidName(f.name)) { bValid = false }
+                if (f?.namedOperator && !IsValidName_AllowEmpty(f?.namedOperator)) { bValid = false }
+                if (f?.permission && !IsValidPermissionIndex(f?.permission)) { bValid = false }
+                if (!f?.permission && !f?.namedOperator) { bValid = false; }
+                if (f?.weight && !IsValidUint(f.weight)) { bValid = false; }
+            })
+        })
+    })
+    if (!bValid) return false
+
     let new_nodes: MachineNodeObject[] = [];
     nodes.forEach((node) => {
         let n = txb.moveCall({
             target:PROTOCOL.NodeFn('new') as FnCallType,
-            arguments:[txb.pure(name_data(node.name)), txb.pure(description_data(node.description))]
+            arguments:[txb.pure(node.name), txb.pure(node.description)]
         });
         node.pairs.forEach((pair) => {
+            let threshold = pair?.threshold ? txb.pure(BCS_CONVERT.ser_option_u64(pair.threshold)) : OptionNone(txb);
+
             pair.forwards.forEach((forward) => {
-                if (!forward?.namedOperator && !forward?.permission) { return }
-                let weight = txb.pure(1); 
-                if (forward?.weight && forward.weight >  0) { 
-                    weight = txb.pure(forward.weight) 
-                }
-                
-                let per = txb.pure([], BCS.U8); 
-                if (forward?.permission) {
-                    per = txb.pure(BCS_CONVERT.ser_option_u64(forward.permission as number));
-                }; 
-                let namedOperator = txb.pure('');
-                if (forward?.namedOperator) {
-                    namedOperator = txb.pure(forward.namedOperator)
-                }; let f;
+                let weight = forward?.weight ? forward.weight : 1;
+                let perm = forward?.permission ? txb.pure(BCS_CONVERT.ser_option_u64(forward.permission)) : OptionNone(txb); 
+                let namedOperator = forward?.namedOperator ?  txb.pure(forward.namedOperator) : txb.pure('');
+                let f;
 
-                if (forward?.guard_address) {
+                if (forward?.guard) {
                     f = txb.moveCall({ 
                         target:PROTOCOL.NodeFn('forward') as FnCallType,
-                            arguments:[namedOperator, weight, txb.object(forward.guard_address), per]
+                            arguments:[namedOperator, txb.pure(weight), txb.object(TXB_OBJECT(txb, forward.guard)), perm]
                     });                        
                 } else {
                     f = txb.moveCall({ 
                         target:PROTOCOL.NodeFn('forward2') as FnCallType,
-                            arguments:[namedOperator, weight, per]
+                            arguments:[namedOperator, txb.pure(weight), perm]
                     });                
                 }
                 txb.moveCall({ // add forward
                     target:PROTOCOL.NodeFn('forward_add') as FnCallType,
-                        arguments:[n, txb.pure(pair.prior_node), txb.pure(name_data(forward.name)),  
-                            txb.pure(BCS_CONVERT.ser_option_u64(pair.threshold)), f]
+                        arguments:[n, txb.pure(pair.prior_node), txb.pure(forward.name),  threshold, f]
                 });                
             }); 
         }); 
         new_nodes.push(n); 
-    }); machine_add_node2(txb, machine, permission, new_nodes, passport)
+    }); return machine_add_node2(txb, machine, permission, new_nodes, passport)
 }
 // 把个人拥有的node加入到machine
-export function machine_add_node2(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, nodes:MachineNodeObject[], passport?:PassportObject) {
+export function machine_add_node2(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    nodes:MachineNodeObject[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!nodes) return false;
+
     if (passport) {
         txb.moveCall({ // add node
             target:PROTOCOL.MachineFn('node_add_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.makeMoveVec({objects:nodes}), permission]
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:nodes}), TXB_OBJECT(txb, permission)]
         });     
     } else {
         txb.moveCall({ // add node
             target:PROTOCOL.MachineFn('node_add') as FnCallType,
-            arguments:[machine, txb.makeMoveVec({objects:nodes}), permission]
+            arguments:[TXB_OBJECT(txb, machine), txb.makeMoveVec({objects:nodes}), TXB_OBJECT(txb, permission)]
         });     
     }    
+    return true
 }
 // 从machine把node移动到个人地址
-export function machine_remove_node(txb:TransactionBlock, machine:MachineObject, permission:TransactionResult, nodes_name:string[], receive_address:string, passport?:PassportObject) {
+export function machine_remove_node(txb:TransactionBlock, machine:MachineObject, permission:TransactionResult, 
+    nodes_name:string[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!nodes_name || !IsValidArray(nodes_name, IsValidName)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('node_remove_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
         });  
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('node_remove') as FnCallType,
-            arguments:[machine, txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(BCS_CONVERT.ser_vector_string(nodes_name)), permission],
         });
     } 
+    return true;
 }
-export function machine(txb:TransactionBlock, permission:PermissionObject, description:string, endpoint_url?:string, passport?:PassportObject) : MachineObject | undefined {
-    if (endpoint_url && endpoint_url.length > MAX_ENDPOINT_LENGTH) return undefined;
-    let endpoint = endpoint_url? txb.pure(BCS_CONVERT.ser_option_string(endpoint_url)) : txb.pure([], BCS.U8);
+export function machine(txb:TransactionBlock, permission:PermissionObject, description:string, 
+    endpoint?:string, passport?:PassportObject) : MachineObject | boolean {
+    if (!IsValidObjects([permission])) return false;    
+    if (!IsValidDesription(description)) return false;
+    if (endpoint && !IsValidEndpoint(endpoint)) return false;
+    let ep = endpoint? txb.pure(BCS_CONVERT.ser_option_string(endpoint)) : OptionNone(txb);
 
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('new_with_passport') as FnCallType,
-            arguments:[passport, txb.pure(description_data(description)), endpoint, permission],
+            arguments:[passport, txb.pure(description), ep, TXB_OBJECT(txb, permission)],
         })
     } else {
-        //console.log(endpoint)
         return txb.moveCall({
             target:PROTOCOL.MachineFn('new') as FnCallType,
-            arguments:[txb.pure(description_data(description)), endpoint, permission],
+            arguments:[txb.pure(description), ep, TXB_OBJECT(txb, permission)],
         })
     }
 }
-export function destroy(txb:TransactionBlock, machine:MachineObject) {
-    return txb.moveCall({
+export function destroy(txb:TransactionBlock, machine:MachineObject) : boolean{
+    if (!IsValidObjects([machine])) return false;
+    txb.moveCall({
         target:PROTOCOL.MachineFn('destroy') as FnCallType,
-        arguments: [machine],
-    })   
+        arguments: [TXB_OBJECT(txb, machine)],
+    })  
+    return true 
 }
-export function launch(txb:TransactionBlock, machine:MachineObject) : MachineAddress {
+export function launch(txb:TransactionBlock, machine:MachineObject) : MachineAddress | boolean {
+    if (!IsValidObjects([machine])) return false;
     return txb.moveCall({
         target:PROTOCOL.MachineFn('create') as FnCallType,
-        arguments:[machine],
+        arguments:[TXB_OBJECT(txb, machine)],
     })
 }
-export function machine_set_description(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, description:string, passport?:PassportObject) {
+export function machine_set_description(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    description:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!IsValidDesription(description)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('description_set_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.pure(description_data(description)), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(description), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('description_set') as FnCallType,
-            arguments:[machine, txb.pure(description_data(description)), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(description), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_add_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, repository:RepositoryObject, passport?:PassportObject) {
+export function machine_add_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    repository:RepositoryObject, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, repository])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('repository_add_with_passport') as FnCallType,
-            arguments:[passport, machine, repository, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('repository_add') as FnCallType,
-            arguments:[machine, repository, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
 
-export function machine_remove_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, repositories:string[], removeall?:boolean, passport?:PassportObject) {
+export function machine_remove_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    repositories:string[], removeall?:boolean, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (!removeall && !repositories) return false;
+    if (!IsValidArray(repositories, IsValidAddress)) return false;
+
     if (passport) {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_all_with_passport') as FnCallType,
-                arguments:[passport, machine, permission],
+                arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, machine)],
             })
         } else {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_with_passport') as FnCallType,
-                arguments:[passport, machine, txb.pure(repositories, 'vector<address>'), permission],
+                arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(repositories, 'vector<address>'), TXB_OBJECT(txb, permission)],
             })
         }   
     } else {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove_all') as FnCallType,
-                arguments:[machine, permission],
+                arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })
         } else {
             txb.moveCall({
                 target:PROTOCOL.MachineFn('repository_remove') as FnCallType,
-                arguments:[machine, txb.pure(repositories, 'vector<address>'), permission],
+                arguments:[TXB_OBJECT(txb, machine), txb.pure(repositories, 'vector<address>'), TXB_OBJECT(txb, permission)],
             })
         }   
-    }     
+    }   
+    return true  
 }
 
-export function machine_clone(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : MachineObject {
+export function machine_clone(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : MachineObject | boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('clone_with_passport') as FnCallType,
-            arguments:[passport, machine, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     } else {
         return txb.moveCall({
             target:PROTOCOL.MachineFn('clone') as FnCallType,
-            arguments:[machine, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     }
 }
-export function machine_set_endpoint(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, endpoint_url?:string, passport?:PassportObject) {
-    if (endpoint_url && endpoint_url.length > MAX_ENDPOINT_LENGTH) return undefined;
-    let endpoint = endpoint_url? txb.pure(BCS_CONVERT.ser_option_string(endpoint_url)) : txb.pure([], BCS.U8);
+export function machine_set_endpoint(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    endpoint?:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
+    if (endpoint && !IsValidEndpoint(endpoint)) return false;
+    let ep = endpoint? txb.pure(BCS_CONVERT.ser_option_string(endpoint)) : OptionNone(txb);
 
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('endpoint_set_with_passport') as FnCallType,
-            arguments:[passport, machine, endpoint, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), ep, TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('endpoint_set') as FnCallType,
-            arguments:[machine, endpoint, permission],
+            arguments:[TXB_OBJECT(txb, machine), ep, TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_pause(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, bPaused:boolean, passport?:PassportObject) {
+export function machine_pause(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, bPaused:boolean, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('pause_with_passport') as FnCallType,
-            arguments:[passport, machine, txb.pure(bPaused), permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), txb.pure(bPaused), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('pause') as FnCallType,
-            arguments:[machine, txb.pure(bPaused), permission],
+            arguments:[TXB_OBJECT(txb, machine), txb.pure(bPaused), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
-export function machine_publish(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) {
+export function machine_publish(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.MachineFn('publish_with_passport') as FnCallType,
-            arguments:[passport, machine, permission],
+            arguments:[passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.MachineFn('publish') as FnCallType,
-            arguments:[machine, permission],
+            arguments:[TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })
     }
+    return true
 }
 
-export function change_permission(txb:TransactionBlock, machine:MachineObject, old_permission:PermissionObject, new_permission:PermissionObject) {
+export function change_permission(txb:TransactionBlock, machine:MachineObject, old_permission:PermissionObject, new_permission:PermissionObject) : boolean {
+    if (!IsValidObjects([machine, old_permission, new_permission])) return false;
     txb.moveCall({
         target:PROTOCOL.MachineFn('permission_set') as FnCallType,
-        arguments: [machine, old_permission, new_permission],
+        arguments: [TXB_OBJECT(txb, machine), TXB_OBJECT(txb, old_permission), TXB_OBJECT(txb, new_permission)],
         typeArguments:[]            
     })    
+    return true
 }

package/src/object.graphql

@@ -0,0 +1,30 @@
+{
+  object(
+    address: "0x30feecaf0e3930da9c6deab887413a25e956572330a1071f3b29ad83764ba384"
+  ) {
+    asMoveObject {
+      contents {
+        json
+        type {
+          repr
+        }
+      }
+    }
+    dynamicFields {
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      nodes {
+        name {
+          json
+        }
+        value {
+          ... on MoveValue {
+            json
+          }
+        }
+      }
+    }
+  }
+}

package/src/passport.ts

@@ -1,10 +1,10 @@
 import { SuiObjectResponse, SuiObjectDataOptions } from '@mysten/sui.js/client';
 import { TransactionBlock, TransactionResult, type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
-import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX} from './protocol';
+import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, PassportObject} from './protocol';
 import { parse_object_type, array_unique } from './util';
 import { sense_objects_fn } from './guard';
 
-export const MAX_GUARD_COUNT = 4;
+export const MAX_GUARD_COUNT = 8;
 
 // passport verify for some guards, MUST be in ONE pxb:
 // 0. construct Guard_Query_Objects(passport_quries) from queries for guards of objects
@@ -15,9 +15,8 @@ export const MAX_GUARD_COUNT = 4;
 // 5. ops using passport(guard set on object)
 // 6. destroy passport
 
-export type PassportObject = TransactionResult;
 
-export const passport_quries = async (guards:string[]) : Promise<Guard_Query_Object[]> => {
+export const passport_queries = async (guards:string[]) : Promise<Guard_Query_Object[]> => {
     let sense_objects = guards.map((value) => {
         return {objectid:value, callback:sense_objects_fn, data:[]} as Query_Param
     });
@@ -38,9 +37,9 @@ export const passport_quries = async (guards:string[]) : Promise<Guard_Query_Obj
     })
 }
 // return passport object for using
-export function verify(txb:TransactionBlock, passport_queries:Guard_Query_Object[]) : PassportObject | undefined {
+export function verify(txb:TransactionBlock, passport_queries:Guard_Query_Object[]) : PassportObject | boolean {
     if (passport_queries.length == 0 || passport_queries.length > MAX_GUARD_COUNT) {
-        return undefined;
+        return false;
     }
     let guard_ids = passport_queries.map((value)=>value.id);
     var passport = txb.moveCall({
@@ -76,11 +75,12 @@ export function verify(txb:TransactionBlock, passport_queries:Guard_Query_Object
     return passport;
 }
 
-export function destroy(txb:TransactionBlock, passport:PassportObject) {
+export function destroy(txb:TransactionBlock, passport:PassportObject) : boolean {
     txb.moveCall({
         target: PROTOCOL.PassportFn('destroy') as FnCallType,
         arguments: [ passport ]
     });  
+    return true
 }
 
 export type Guard_Query_Object = {