wowok 1.0.3 → 1.0.5

package/src/permission.ts

@@ -1,12 +1,13 @@
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS } from '@mysten/bcs';
-import { description_data, FnCallType, PROTOCOL, TxbObject, GuardObject, TXB_OBJECT} from './protocol';
+import { FnCallType, PROTOCOL, TxbObject, PermissionObject, PermissionAddress, TXB_OBJECT, IsValidDesription, 
+    IsValidObjects, IsValidAddress, IsValidArray, GuardObject, IsValidUint} from './protocol';
 import { array_unique } from './util';
 
 
 export const MAX_ADMIN_COUNT = 64;
-export const MAX_ENTITY_COUNT = 1024;
-export const MAX_PERMISSION_INDEX_COUNT = 512;
+export const MAX_ENTITY_COUNT = 2000;
+export const MAX_PERMISSION_INDEX_COUNT = 200;
 
 export enum PermissionIndex {
     repository = 100,
@@ -84,34 +85,70 @@ export enum PermissionIndex {
     progress_bind_task = 652,
     progress_set_context_repository = 653,
     progress_unhold = 654,
+    user_defined_start = 10000,
 }
+
+export type PermissionIndexType = PermissionIndex | number;
+export const IsValidUserDefinedIndex = (index:number) : boolean => { 
+    return index >= PermissionIndex.user_defined_start && IsValidUint(index)
+}
+export const IsValidPermissionIndex = (index:PermissionIndexType) : boolean => {
+    //console.log(index)
+    if (Object.values(PermissionIndex).includes(index)) {
+        return true
+    }
+    //console.log(Object.keys(PermissionIndex))
+    return IsValidUserDefinedIndex(index);
+}
+
 export type Permission_Index = {
-    index:PermissionIndex;
+    index: PermissionIndexType;
     guard?: TxbObject;
 }
+
 export type Permission_Entity = {
-    who:string;
+    entity_address:string;
     permissions:Permission_Index[];
 }
 
-export type PermissionAddress = TransactionResult;
-export type PermissionObject = TransactionResult;
+export function permission(txb:TransactionBlock, description:string) : PermissionObject | boolean {
+    if (!IsValidDesription(description)) return false;
 
-export function permission(txb:TransactionBlock, description:string) : PermissionObject {
     return txb.moveCall({
         target: PROTOCOL.PermissionFn('new') as FnCallType,
-        arguments: [txb.pure(description_data(description))]
+        arguments: [txb.pure(description)]
     });
 }
 
-export function launch(txb:TransactionBlock, permission:PermissionObject) : PermissionAddress {
+export function launch(txb:TransactionBlock, permission:PermissionObject) : PermissionAddress | boolean {
+    if (!IsValidObjects([permission])) return false;
     return txb.moveCall({ // address returned
         target:PROTOCOL.PermissionFn('create')  as FnCallType,
-        arguments:[ permission ]        
+        arguments:[ TXB_OBJECT(txb, permission) ]        
     })
 }
+export function destroy(txb:TransactionBlock, permission:PermissionObject) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('destroy') as FnCallType,
+        arguments: [TXB_OBJECT(txb, permission)],
+    })   
+    return true
+}
+export function add_entity(txb:TransactionBlock, permission:PermissionObject, entities:Permission_Entity[]) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!entities) return false;
+
+    let bValid = true;
+    let e = entities.forEach((v) => {
+        if (!IsValidAddress(v.entity_address)) bValid = false;
+        v.permissions.forEach((p) => {
+            if (!IsValidPermissionIndex(p.index)) bValid = false;
+            if (p?.guard && !IsValidObjects([p.guard])) bValid = false;
+        })
+    });
+    if (!bValid) return false;
 
-export function add_entity(txb:TransactionBlock, permission:PermissionObject, entities:Permission_Entity[]) {
     let guards:any[]  = [];
     for (let i = 0; i < entities.length; i++) {
         let entity = entities[i];
@@ -119,106 +156,125 @@ export function add_entity(txb:TransactionBlock, permission:PermissionObject, en
 
         for (let j = 0; j <  entity.permissions.length; j++) {
             let index = entity.permissions[j];
-            if (index?.guard) {
-                guards.push({who:entity.who, index:index.index, guard:index.guard});
+            if (!IsValidPermissionIndex(index.index)) {
+                continue;
             }
             
             if (!indexes.includes(index.index))   {
                 indexes.push(index.index);
+                if (index?.guard) {
+                    guards.push({entity_address:entity.entity_address, index:index.index, guard:index.guard});
+                }
             }      
         }    
         if (indexes.length > 0) {
             txb.moveCall({
                 target:PROTOCOL.PermissionFn('add_batch') as FnCallType,
-                arguments:[permission, txb.pure(entity.who, BCS.ADDRESS), txb.pure(indexes, 'vector<u64>')]
+                arguments:[TXB_OBJECT(txb, permission), txb.pure(entity.entity_address, BCS.ADDRESS), txb.pure(indexes, 'vector<u64>')]
             })            
         }
     } 
     // set guards
-    guards.forEach(({who, index, guard}) => {
+    guards.forEach(({entity_address, index, guard}) => {
         txb.moveCall({
             target:PROTOCOL.PermissionFn('guard_set') as FnCallType,
-            arguments:[ permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
+            arguments:[ TXB_OBJECT(txb, permission), txb.pure(entity_address, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
         })
     })
+
+    return true;
 }
 
 // guard: undefine to set none
-export function set_guard(txb:TransactionBlock, permission:PermissionObject, who:string, index:number, guard?:string | GuardObject) {
+export function set_guard(txb:TransactionBlock, permission:PermissionObject, entity_address:string, 
+    index:PermissionIndexType, guard?:GuardObject) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!IsValidAddress(entity_address) || !IsValidPermissionIndex(index)) return false;
+
     if (guard) {
         txb.moveCall({
             target:PROTOCOL.PermissionFn('guard_set') as FnCallType,
-            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
+            arguments:[TXB_OBJECT(txb, permission), txb.pure(entity_address, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard)]
         })    
     } else {
         txb.moveCall({
             target:PROTOCOL.PermissionFn('guard_none') as FnCallType,
-            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64)]
+            arguments:[TXB_OBJECT(txb, permission), txb.pure(entity_address, BCS.ADDRESS), txb.pure(index, BCS.U64)]
         })       
     }
+    return true;
 }
 
-export function add_or_modify(txb:TransactionBlock, permission:PermissionObject, who:string, index:number, modifyIfOldExist?:boolean, guard?:string | GuardObject) {
-    if (guard) {
-        txb.moveCall({
-            target:PROTOCOL.PermissionFn('add_or_modify') as FnCallType,
-            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), TXB_OBJECT(txb, guard), txb.pure(modifyIfOldExist, BCS.BOOL)]
-        })    
-    } else {
-        txb.moveCall({
-            target:PROTOCOL.PermissionFn('add_or_modify') as FnCallType,
-            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, BCS.U64), txb.pure([], BCS.U8), txb.pure(modifyIfOldExist, BCS.BOOL)]
-        })   
-    }
-}
-export function remove_index(txb:TransactionBlock, permission:PermissionObject, who:string, index:number[]) {
-    if (index) {
-        txb.moveCall({
-            target:PROTOCOL.PermissionFn('remove_index') as FnCallType,
-            arguments:[permission, txb.pure(who, BCS.ADDRESS), txb.pure(index, 'vector<u64>')]
-        })            
-    }
+export function remove_index(txb:TransactionBlock, permission:PermissionObject, entity_address:string, 
+    index:PermissionIndexType[]) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!IsValidAddress(entity_address)) return false;
+    if (!index || !(IsValidArray(index, IsValidPermissionIndex))) return false;
+
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('remove_index') as FnCallType,
+        arguments:[TXB_OBJECT(txb, permission), txb.pure(entity_address, BCS.ADDRESS), txb.pure(array_unique(index), 'vector<u64>')]
+    })            
+    return true;
 }
-export function remove_entity(txb:TransactionBlock, permission:PermissionObject, who:string[]) {
-    if (who) {
-        txb.moveCall({
-            target:PROTOCOL.PermissionFn('remove') as FnCallType,
-            arguments:[permission, txb.pure(who, 'vector<address>')]
-        })           
-    }
+export function remove_entity(txb:TransactionBlock, permission:PermissionObject, entity_address:string[]) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!entity_address || !IsValidArray(entity_address, IsValidAddress)) return false;
+
+    txb.moveCall({
+        target:PROTOCOL.PermissionFn('remove') as FnCallType,
+        arguments:[TXB_OBJECT(txb, permission), txb.pure(array_unique(entity_address), 'vector<address>')]
+    })           
+    return true;
 }
-export function set_description(txb:TransactionBlock, permission:PermissionObject, description:string) {
+export function set_description(txb:TransactionBlock, permission:PermissionObject, description:string) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!IsValidDesription(description)) return false;
+
     txb.moveCall({
         target:PROTOCOL.PermissionFn('description_set') as FnCallType,
-        arguments: [permission, txb.pure(description_data(description))]
+        arguments: [TXB_OBJECT(txb, permission), txb.pure(description)]
     })
+    return true;
 }
 
-export function add_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[]) {
-    let n = array_unique(admin); 
+export function add_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[]) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!admin || !IsValidArray(admin, IsValidAddress)) return false;
+
     txb.moveCall({
         target:PROTOCOL.PermissionFn('admin_add_batch')  as FnCallType,
-        arguments:[permission, txb.pure(n, 'vector<address>')]
-    });    
+        arguments:[TXB_OBJECT(txb, permission), txb.pure(array_unique(admin), 'vector<address>')]
+    });           
+    return true;
 }
 
-export function remove_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[], removeall?:boolean) {
+export function remove_admin(txb:TransactionBlock, permission:PermissionObject, admin:string[], removeall?:boolean) : boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!removeall && !admin) return false;
+    if (!IsValidArray(admin, IsValidAddress)) return false; 
+    
     if (removeall) {
         txb.moveCall({
             target:PROTOCOL.PermissionFn('admins_clear')  as FnCallType,
-            arguments:[permission]
+            arguments:[TXB_OBJECT(txb, permission)]
         });    
-    } else {
+    } else if (admin) {
         txb.moveCall({
             target:PROTOCOL.PermissionFn('admin_remove_batch')  as FnCallType,
-            arguments:[permission, txb.pure(admin, 'vector<address>')]
+            arguments:[TXB_OBJECT(txb, permission), txb.pure(array_unique(admin), 'vector<address>')]
         });            
     }
+    return true
 }
 
-export function change_owner(txb:TransactionBlock, permission:PermissionObject, new_owner:string) {
+export function change_owner(txb:TransactionBlock, permission:PermissionObject, new_owner:string) :boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!IsValidAddress(new_owner)) return false;
+    
     txb.moveCall({
         target:PROTOCOL.PermissionFn('builder_set')  as FnCallType,
-        arguments:[permission, txb.pure(new_owner, BCS.ADDRESS)]
+        arguments:[TXB_OBJECT(txb, permission), txb.pure(new_owner, BCS.ADDRESS)]
     });        
+    return true
 }

package/src/progress.ts

@@ -1,139 +1,225 @@
-import { SuiClient, getFullnodeUrl, SuiObjectResponse } from '@mysten/sui.js/client';
-import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
-import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
-import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
-import { name_data, FnCallType, PROTOCOL,} from './protocol';
-import { verify,  PassportObject} from './passport'
-import { PermissionIndex, PermissionObject } from './permission'
-import { RepositoryObject } from './repository';
-import { MachineObject } from './machine';
-
-export type ProgressObject = TransactionResult;
-export type ProgressAddress = TransactionResult;
-export const MAX_NAMED_OPERATOR_COUNT = 64;
-
-export function progress(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : ProgressObject {
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+import { BCS } from '@mysten/bcs';
+import { FnCallType, PROTOCOL, PermissionObject, RepositoryObject, PassportObject, MachineObject, TXB_OBJECT, 
+    ProgressObject, ProgressAddress, IsValidName, IsValidAddress, IsValidArray, OptionNone,  IsValidObjects, 
+    IsValidInt} from './protocol';
+import { BCS_CONVERT, array_unique } from './util'
+
+export const MAX_NAMED_OPERATOR_COUNT = 100;
+
+export function progress(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : ProgressObject | boolean {
+    if (!IsValidObjects([machine, permission])) return false;
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.ProgressFn('new_with_passport') as FnCallType,
-            arguments: [passport, machine, permission],
+            arguments: [passport, TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })    
     } else {
         return txb.moveCall({
             target:PROTOCOL.ProgressFn('new') as FnCallType,
-            arguments: [machine, permission],
+            arguments: [TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })    
     }
 }
-export function launch(txb:TransactionBlock, progress:ProgressObject) : ProgressAddress {
+export function launch(txb:TransactionBlock, progress:ProgressObject) : ProgressAddress | boolean {
+    if (!IsValidObjects([progress])) return false;
     return txb.moveCall({
         target:PROTOCOL.ProgressFn('create') as FnCallType,
-        arguments: [progress],
+        arguments: [TXB_OBJECT(txb, progress)],
     })   
 }
-export function launch_as_child(txb:TransactionBlock, progress:ProgressObject, parent:ProgressObject, parent_next:ProgressNext) : ProgressAddress {
+export function launch_as_child(txb:TransactionBlock, progress:ProgressObject, parent:ProgressObject, parent_next:ProgressNext) : ProgressAddress | boolean {
+    if (!IsValidObjects([progress, parent])) return false;
+    if (!IsValidProgressNext(parent_next)) return false;
+
     return txb.moveCall({
         target:PROTOCOL.ProgressFn('create_as_child') as FnCallType,
-        arguments: [progress, parent, txb.pure(parent_next.next_node_name), txb.pure(name_data(parent_next.forward))],
+        arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, parent), txb.pure(parent_next.next_node_name), txb.pure(parent_next.forward)],
     })   
 }
-export function destroy(txb:TransactionBlock, progress:ProgressObject) {
-    return txb.moveCall({
+export function destroy(txb:TransactionBlock, progress:ProgressObject) : boolean {
+    if (!IsValidObjects([progress])) return false;
+    txb.moveCall({
         target:PROTOCOL.ProgressFn('destroy') as FnCallType,
-        arguments: [progress],
+        arguments: [TXB_OBJECT(txb, progress)],
     })   
+    return true
 }
-export function progress_set_namedOperator(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, name:string, addresses:string[], passport?:PassportObject) {
-    if (addresses.length == 0 || name.length == 0 || addresses.length > MAX_NAMED_OPERATOR_COUNT) return undefined;
+export function progress_set_namedOperator(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    progress:ProgressObject, name:string, addresses:string[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (!IsValidName(name)) return false;
+    if (!addresses || addresses.length > MAX_NAMED_OPERATOR_COUNT) return false;
+    if (!IsValidArray(addresses, IsValidAddress)) return false;
 
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('namedOperator_set_with_passport') as FnCallType,
-            arguments: [passport, progress, txb.pure(name_data(name)), txb.pure(addresses, 'vector<address>'), 
-                machine, permission],
+            arguments: [passport, TXB_OBJECT(txb, progress), txb.pure(name), txb.pure(array_unique(addresses), 'vector<address>'), 
+            TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })  
     } else {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('namedOperator_set') as FnCallType,
-            arguments: [progress, txb.pure(name_data(name)), txb.pure(addresses, 'vector<address>'), 
-                machine, permission],
+            arguments: [TXB_OBJECT(txb, progress), txb.pure(name), txb.pure(array_unique(addresses), 'vector<address>'), 
+            TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })  
     }  
+    return true
 }
-export function progress_bind_task(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, task_address:string, passport?:PassportObject) {
+export function progress_bind_task(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    progress:ProgressObject, task_address:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (!IsValidAddress(task_address)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('task_set_with_passport') as FnCallType,
-            arguments: [passport, progress, txb.pure(task_address, BCS.ADDRESS), machine, permission],
+            arguments: [passport, TXB_OBJECT(txb, progress), txb.pure(task_address, BCS.ADDRESS), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })   
     } else {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('task_set') as FnCallType,
-            arguments: [progress, txb.pure(task_address, BCS.ADDRESS), machine, permission],
+            arguments: [TXB_OBJECT(txb, progress), txb.pure(task_address, BCS.ADDRESS), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })   
     } 
+    return true
 }
-export function progress_set_context_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, repository?:RepositoryObject, passport?:PassportObject) {
+export function progress_set_context_repository(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    progress:ProgressObject, repository?:RepositoryObject, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
     if (passport) {
         if (repository) {
             txb.moveCall({
                 target:PROTOCOL.ProgressFn('context_repository_set_with_passport') as FnCallType,
-                arguments: [passport, progress, repository, machine, permission],
+                arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })            
         } else {
             txb.moveCall({
                 target:PROTOCOL.ProgressFn('context_repository_none_with_passport') as FnCallType,
-                arguments: [passport, progress, machine, permission],
+                arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })           
         }
     } else {
         if (repository) {
             txb.moveCall({
                 target:PROTOCOL.ProgressFn('context_repository_set') as FnCallType,
-                arguments: [progress, repository, machine, permission],
+                arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, repository), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })            
         } else {
             txb.moveCall({
                 target:PROTOCOL.ProgressFn('context_repository_none') as FnCallType,
-                arguments: [progress, machine, permission],
+                arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
             })           
         }
     }
+    return true
 }
-export function progress_unhold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext) {
-    txb.moveCall({
-        target:PROTOCOL.ProgressFn('unhold') as FnCallType,
-        arguments: [progress, machine, txb.pure(next.next_node_name), txb.pure(name_data(next.forward)), permission],
-    })   
+export function progress_unhold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, 
+    progress:ProgressObject, next:ProgressNext, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (!IsValidProgressNext(next)) return false;
+    
+    if (passport) {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('unhold_with_passport') as FnCallType,
+            arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(next.next_node_name), txb.pure(next.forward), TXB_OBJECT(txb, permission)],
+        })     
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('unhold') as FnCallType,
+            arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(next.next_node_name), txb.pure(next.forward), TXB_OBJECT(txb, permission)],
+        })           
+    }
+
+    return true
 }
 
-export type ProgressNext = {
-    next_node_name: string;
-    forward: string;
+export type ParentProgress = {
+    parent_progress_id: string;
+    parent_session_id: number;
 }
-export function next(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext,
-    deliverables_address?:string, passport?:PassportObject) {
-        let diliverable = txb.pure([], BCS.U8);
-        if (deliverables_address) { diliverable = txb.pure(deliverables_address, BCS.ADDRESS)}
+export function progress_parent(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, 
+    parent_progress?:ParentProgress, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (parent_progress && (!IsValidAddress(parent_progress.parent_progress_id) || !IsValidInt(parent_progress.parent_session_id))) return false;
 
-        if (passport) {
+    if (passport) {
+        if (parent_progress) {
             txb.moveCall({
-                target:PROTOCOL.ProgressFn('run_with_passport') as FnCallType,
-                arguments: [passport, progress, machine, txb.pure(next.next_node_name), 
-                    txb.pure(name_data(next.forward)), diliverable, permission],
-            })    
+                target:PROTOCOL.ProgressFn('parent_set_with_passport') as FnCallType,
+                arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(parent_progress.parent_progress_id, BCS.ADDRESS), 
+                    txb.pure(parent_progress.parent_session_id, BCS.U64), TXB_OBJECT(txb, permission)],
+            })  
         } else {
             txb.moveCall({
-                target:PROTOCOL.ProgressFn('run') as FnCallType,
-                arguments: [progress, machine, txb.pure(next.next_node_name), 
-                    txb.pure(name_data(next.forward)), diliverable, permission],
-            })               
+                target:PROTOCOL.ProgressFn('parent_none_with_passport') as FnCallType,
+                arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
+            }) 
         }
+    } else {
+        if (parent_progress) {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('parent_set') as FnCallType,
+                arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(parent_progress.parent_progress_id, BCS.ADDRESS), 
+                    txb.pure(parent_progress.parent_session_id, BCS.U64), TXB_OBJECT(txb, permission)],
+            })  
+        } else {
+            txb.moveCall({
+                target:PROTOCOL.ProgressFn('parent_none') as FnCallType,
+                arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
+            }) 
+        } 
+    }
+
+    return true
+}
+
+export type ProgressNext = {
+    next_node_name: string;
+    forward: string;
+}
+function IsValidProgressNext(next:ProgressNext) : boolean {
+    return IsValidName(next.forward)  && IsValidName(next.next_node_name);
+}
+
+export function next(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, 
+    next:ProgressNext, deliverables_address?:string, sub_progress_id?:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (!IsValidProgressNext(next)) return false;
+    if (deliverables_address && !IsValidAddress(deliverables_address)) return false;
+    if (sub_progress_id && !IsValidAddress(sub_progress_id)) return false;
+
+    let diliverable = deliverables_address? txb.pure(BCS_CONVERT.ser_option_address(deliverables_address)) : OptionNone(txb)
+    let sub = sub_progress_id? txb.pure(BCS_CONVERT.ser_option_address(sub_progress_id)) : OptionNone(txb)
+    
+    if (passport) {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('next_with_passport') as FnCallType,
+            arguments: [passport, TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(next.next_node_name, BCS.STRING), 
+                txb.pure(next.forward, BCS.STRING), diliverable, sub, TXB_OBJECT(txb, permission)],
+        })    
+    } else {
+        txb.moveCall({
+            target:PROTOCOL.ProgressFn('next') as FnCallType,
+            arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(next.next_node_name, BCS.STRING), 
+                txb.pure(next.forward, BCS.STRING), diliverable, sub, TXB_OBJECT(txb, permission)],
+        })               
+    }
+    return true
 }
-export function hold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, next:ProgressNext, hold:boolean) {
+
+export function hold(txb:TransactionBlock, machine:MachineObject, permission:PermissionObject, progress:ProgressObject, 
+    next:ProgressNext, hold:boolean) : boolean {
+    if (!IsValidObjects([machine, permission, progress])) return false;
+    if (!IsValidProgressNext(next)) return false;
+
     txb.moveCall({
         target:PROTOCOL.ProgressFn('hold') as FnCallType,
-        arguments: [progress, machine, txb.pure(next.next_node_name), 
-            txb.pure(name_data(next.forward)), txb.pure(hold, BCS.BOOL), permission],
+        arguments: [TXB_OBJECT(txb, progress), TXB_OBJECT(txb, machine), txb.pure(next.next_node_name), 
+            txb.pure(next.forward), txb.pure(hold, BCS.BOOL), TXB_OBJECT(txb, permission)],
     })  
-}
+    return true
+}
+
+