wowok 1.2.5 → 1.2.8

package/src/permission.ts

@@ -1,6 +1,6 @@
 import { BCS } from '@mysten/bcs';
 import { FnCallType, TxbObject, PermissionObject, PermissionAddress, GuardObject, Protocol} from './protocol';
-import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUint, Bcs} from './utils';
+import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUintLarge, Bcs, IsValidName} from './utils';
 import { ERROR, Errors } from './exception';
 import { ValueType } from './protocol';
 
@@ -8,38 +8,31 @@ export enum PermissionIndex {
     repository = 100,
     repository_set_description_set = 101,
     repository_set_policy_mode = 102,
-    repository_add_policies = 103,
-    repository_remove_policies = 104,
+    repository_add_remove_policies = 103,
     repository_set_policy_description = 105,
     repository_set_policy_permission = 106,
-    repository_reference_add = 107,
-    repository_reference_remove = 108,
-    repository_reference_removeall = 108,
+    repository_reference = 107,
+
     vote = 150,
     vote_set_description = 151,
     vote_set_reference = 152, 
-    vote_add_guard = 153,
-    vote_remove_guard = 154,
-    vote_add_option = 155,
-    vote_remove_option = 156,
+    vote_guard = 153,
+    vote_option = 155,
     vote_set_max_choice_count = 157,
     vote_open_voting = 158,
     vote_lock_deadline = 159,
     vote_expand_deadline = 160,
     vote_lock_guard = 161,
+
     service = 200,
     service_set_description = 201,
     service_set_price = 202,
-    service_set_stock = 203,
-    service_add_stock = 203,
-    service_reduce_stock = 203,
+    service_set_add_reduce_stock = 203,
+    service_set_sale_endpoint = 204,
     service_set_payee = 205,
-    service_repository_add = 206,
-    service_repository_remove = 207,
-    service_add_withdraw_guards = 208,
-    service_remove_withdraw_guards  = 208,
-    service_add_refund_guards = 210,
-    service_remove_refund_guards = 210,
+    service_repository = 206,
+    service_withdraw_guards = 208,
+    service_refund_guards = 210,
     service_add_sales = 212,
     service_remove_sales = 213,
     service_discount_transfer = 214,
@@ -49,35 +42,33 @@ export enum PermissionIndex {
     service_set_endpoint = 219,
     service_publish = 220,
     service_clone = 221,
-    service_set_customer_required = 222,
-    service_remove_customer_required = 222,
-    service_change_required_pubkey = 222,
+    service_customer_required = 222,
     service_change_order_required_pubkey = 224,
     service_pause = 225,
+
     reward = 240,
     reward_refund = 241,
     reward_expand_time = 242,
-    reward_add_guard = 243,
-    reward_remove_guard = 244,
+    reward_guard = 243,
     reward_set_description = 245,
     reward_lock_guards = 246,
+
     demand = 260,
     demand_refund = 261,
     demand_expand_time = 262,
     demand_set_guard = 263,
     demand_set_description = 264,
     demand_yes = 265,
+
     machine = 600,
     machine_set_description = 601,
-    machine_add_repository = 602,
-    machine_remove_repository = 603,
+    machine_repository = 602,
     machine_clone =  604,
-    machine_add_node = 606,
-    machine_add_node2 = 606,
-    machine_remove_node = 607,
+    machine_node = 606,
     machine_set_endpoint = 608,
     machine_pause = 609,
     machine_publish = 610,
+
     progress = 650,
     progress_set_namedOperator = 651,
     progress_bind_task = 652,
@@ -86,6 +77,85 @@ export enum PermissionIndex {
     user_defined_start = 10000,
 }
 
+export interface PermissionInfoType {
+    index: number;
+    name:string;
+    description:string;
+    module: string;
+    guard?: string;
+}
+
+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'},
+    {index:PermissionIndex.repository_set_policy_mode, name:'Policy mode', description:'Set Repository policy mode', module: 'repository'},
+    {index:PermissionIndex.repository_add_remove_policies, name:'Policy', description:'Add/Remove Repository policy', module: 'repository'},
+    {index:PermissionIndex.repository_set_policy_description, name:'Policy Description', description:'Set Repository policy description', module: 'repository'},
+    {index:PermissionIndex.repository_set_policy_permission, name:'Policy Permission', description:'Set Repository policy permission',  module: 'repository'},
+    {index:PermissionIndex.repository_reference, name:'Reference', description:'Set Repository reference', module: 'repository'},
+
+    {index:PermissionIndex.vote, name:'Vote', description:'Launch new Vote', module: 'vote'},
+    {index:PermissionIndex.vote_set_description, name:'Description', description:'Set Vote description', module: 'vote'},
+    {index:PermissionIndex.vote_set_reference, name:'Reference', description:'Set Vote reference', module: 'vote'},
+    {index:PermissionIndex.vote_guard, name:'Guard', description:'Set Vote guards', module: 'vote'},
+    {index:PermissionIndex.vote_option, name:'Option', description:'Set Vote options', module: 'vote'},
+    {index:PermissionIndex.vote_set_max_choice_count, name:'Choice count', description:'Set Vote max choice count', module: 'vote'},
+    {index:PermissionIndex.vote_open_voting, name:'Open voting', description:'Open voting', module: 'vote'},
+    {index:PermissionIndex.vote_lock_deadline, name:'Lock deadline', description:'Set Vote deadline immutable', module: 'vote'},
+    {index:PermissionIndex.vote_expand_deadline, name:'Expand deadline', description:'Expand Vote deadline', module: 'vote'},
+    {index:PermissionIndex.vote_lock_guard, name:'Lock Guard', description:'Set Vote guards immutable', module: 'vote'},
+
+    {index:PermissionIndex.service, name:'Service', description:'Launch new Service', module: 'service'},
+    {index:PermissionIndex.service_set_description, name:'Description', description:'Set Service description', module: 'service'},
+    {index:PermissionIndex.service_set_price, name:'Price', description:'Set Service item price', module: 'service'},
+    {index:PermissionIndex.service_set_add_reduce_stock, name:'Inventory', description:'Set Service item inventory', module: 'service'},
+    {index:PermissionIndex.service_set_payee, name:'Payee', description:'Set Service payee', module: 'service'},
+    {index:PermissionIndex.service_repository, name:'Repository', description:'Set Service repositories', module: 'service'},
+    {index:PermissionIndex.service_withdraw_guards, name:'Withdraw Guard', description:'Set Service withdraw guards', module: 'service'},
+    {index:PermissionIndex.service_refund_guards, name:'Refund Guard', description:'Set Service refund guards', module: 'service'},
+    {index:PermissionIndex.service_add_sales, name:'Add sales', description:'Add sale items for Service', module: 'service'},
+    {index:PermissionIndex.service_remove_sales, name:'Remove sales', description:'Remove sale items for Service', module: 'service'},
+    {index:PermissionIndex.service_discount_transfer, name:'Discount', description:'Launch discounts for Service', module: 'service'},
+    {index:PermissionIndex.service_withdraw, name:'Withdraw', description:'Widthraw from Service orders', module: 'service'},
+    {index:PermissionIndex.service_set_buy_guard, name:'Buyer Guard', description:'Set Guard of buying for Service', module: 'service'},
+    {index:PermissionIndex.service_set_machine, name:'Machine', description:'Set Machine for Service', module: 'service'},
+    {index:PermissionIndex.service_set_endpoint, name:'Endpoint', description:'Set Service endpoint', module: 'service'},
+    {index:PermissionIndex.service_publish, name:'Publish', description:'Publish Service', module: 'service'},
+    {index:PermissionIndex.service_clone, name:'Clone', description:'Clone Service', module: 'service'},
+    {index:PermissionIndex.service_customer_required, name:'Buyer info', description:'Set Service buyer info required', module: 'service'},
+    {index:PermissionIndex.service_change_order_required_pubkey, name:'Order pubkey', description:'Update Serivce order pubkey', module: 'service'},
+    {index:PermissionIndex.service_pause, name:'Pause', description:'Pause/Unpause Service', module: 'service'},
+
+    {index:PermissionIndex.reward, name:'Reward', description:'Launch new Reward', module: 'reward'},
+    {index:PermissionIndex.reward_refund, name:'Refund', description:'Refund from Reward', module: 'reward'},
+    {index:PermissionIndex.reward_expand_time, name:'Expand deadline', description:'Expand Reward deadline', module: 'reward'},
+    {index:PermissionIndex.reward_guard, name:'Guard', description:'build machine', module: 'Set Reward guard'},
+    {index:PermissionIndex.reward_set_description, name:'Description', description:'Set Reward description', module: 'reward'},
+    {index:PermissionIndex.reward_lock_guards, name:'Lock Guard', description:'Set Reward guard immutable', module: 'reward'},
+
+    {index:PermissionIndex.demand, name:'Demand', description:'Launch new Demand', module: 'demand'},
+    {index:PermissionIndex.demand_refund, name:'Refund', description:'Refund from Demand', module: 'demand'},
+    {index:PermissionIndex.demand_expand_time, name:'Expand deadline', description:'Expand Demand deadline', module: 'demand'},
+    {index:PermissionIndex.demand_set_guard, name:'Guard', description:'Set Demand guard', module: 'demand'},
+    {index:PermissionIndex.demand_set_description, name:'Description', description:'Set Demand description', module: 'demand'},
+    {index:PermissionIndex.demand_yes, name:'Yes', description:'Pick the Deamand serice', module: 'demand'},
+
+    {index:PermissionIndex.machine, name: 'Machine', description:'Launch new Machine', module: 'machine'},
+    {index:PermissionIndex.machine_set_description, name: 'Description', description:'Set Machine description', module: 'machine'},
+    {index:PermissionIndex.machine_repository, name: 'Repository', description:'Set Machine repository', module: 'machine'},
+    {index:PermissionIndex.machine_clone, name: 'Clone', description:'Clone Machine', module: 'machine'},
+    {index:PermissionIndex.machine_node, name: 'Node', description:'Set Machine nodes', module: 'machine'},
+    {index:PermissionIndex.machine_set_endpoint, name: 'Endpoint', description:'Set Machine endpoint', module: 'machine'},
+    {index:PermissionIndex.machine_pause, name: 'Pause', description:'Pause/Unpause Machine', module: 'machine'},
+    {index:PermissionIndex.machine_publish, name: 'Publish', description:'Publish Machine', module: 'machine'},
+
+    {index:PermissionIndex.progress, name: 'Progress', description:'Launch new Progress', module: 'progress'},
+    {index:PermissionIndex.progress_set_namedOperator, name: 'Operator', description:'Set Progress operators', module: 'progress'},
+    {index:PermissionIndex.progress_bind_task, name: 'Bind', description:'Set Progress task', module: 'progress'},
+    {index:PermissionIndex.progress_set_context_repository, name: 'Repository', description:'Set Progress repository', module: 'progress'},
+    {index:PermissionIndex.progress_unhold, name: 'Unhold', description:'Release Progress holdings', module: 'progress'},
+]
+
 export type PermissionIndexType = PermissionIndex | number;
 
 export type Permission_Index = {
@@ -141,10 +211,70 @@ export class  Permission {
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
         })  
     }
+    add_userdefine(index: number, name:string) {
+        if (!Permission.IsValidUserDefinedIndex(index)) {
+            ERROR(Errors.IsValidUserDefinedIndex, 'add_userdefine');
+        }
+
+        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)]
+        })   
+    }
+    
+    remove_userdefine(index: number) {
+        if (!Permission.IsValidUserDefinedIndex(index)) {
+            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)]
+        })   
+    }
+
+    change_entity(old_entity: string, new_entity: string) {
+        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) ]
+        })     
+    }
+
+    add_entity2(entities: string[], index?:PermissionIndexType) {
+        if (entities.length === 0) return;
+
+        if (!IsValidArray(entities, IsValidAddress)) {
+            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>')]
+            })       
+        } else {
+            txb.moveCall({
+                target:this.protocol.PermissionFn('add') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(entities), 'vector<address>')]
+            })                   
+        }
+    }
 
     add_entity(entities:Permission_Entity[])  {
         if (!entities) {
-            ERROR(Errors.InvalidParam, 'entities');
+            ERROR(Errors.InvalidParam, 'add_entity');
         }
 
         let bValid = true;
@@ -179,13 +309,13 @@ export class  Permission {
                     }
                 }      
             }    
-            if (indexes.length > 0) {
+            //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>')]
                 })            
-            }
+            //}
         } 
         // set guards
         guards.forEach(({entity_address, index, guard}) => {
@@ -219,8 +349,7 @@ export class  Permission {
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
                     txb.pure(index, BCS.U64)]
             })       
-        }
-        ;
+        };
     }
 
     remove_index(entity_address:string, index:PermissionIndexType[])  {
@@ -275,12 +404,9 @@ export class  Permission {
         ;
     }
 
-    remove_admin(admin?:string[], removeall?:boolean)  {
-        if (!removeall && !admin) {
-            ERROR(Errors.AllInvalid,  'admin & removeall')
-        }
-
-        if (admin && !IsValidArray(admin, IsValidAddress)) {
+    remove_admin(admin:string[], removeall?:boolean)  {
+        if (!removeall &&  admin.length === 0)  return
+        if (!IsValidArray(admin, IsValidAddress)) {
             ERROR(Errors.IsValidArray, 'admin')
         }
 
@@ -314,8 +440,9 @@ export class  Permission {
     static MAX_ADMIN_COUNT = 64;
     static MAX_ENTITY_COUNT = 2000;
     static MAX_PERMISSION_INDEX_COUNT = 200;
+    static MAX_PERSONAL_PERMISSION_COUNT = 200; 
     static IsValidUserDefinedIndex = (index:number)  => { 
-        return index >= PermissionIndex.user_defined_start && IsValidUint(index)
+        return index >= PermissionIndex.user_defined_start && IsValidUintLarge(index)
     }
     
     static IsValidPermissionIndex = (index:PermissionIndexType) : boolean  => {

package/src/progress.ts

@@ -14,6 +14,25 @@ export type ProgressNext = {
 export type ParentProgress = {
     parent_id: string;
     parent_session_id: number;
+    next_node: string;
+    forward: string;
+}
+
+export interface Holder {
+    forward: string;
+    who?:string;
+    sub_progress?:string;
+    deliverables?:string;
+    accomplished:boolean;
+}
+export interface Session {
+    id?:number; // for parent progress's history
+    next_node: string;
+    holders: Holder[];
+    weights: number;
+    threshold: number;
+    node?:string;
+    bComplete?: boolean;
 }
 
 export class Progress {
@@ -34,23 +53,24 @@ export class Progress {
         p.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
         return p
     }
-    static New(protocol:Protocol, machine:MachineObject, permission:PermissionObject, passport?:PassportObject) : Progress {
+    static New(protocol:Protocol, machine:MachineObject, permission:PermissionObject, task?:string, passport?:PassportObject) : Progress {
         if (!Protocol.IsValidObjects([machine, permission])) {
             ERROR(Errors.IsValidObjects, 'machine & permission')
         }
 
         let p = new Progress(protocol, machine, permission);
         let txb = protocol.CurrentSession();
+        let t = task? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_ADDRESS, task)) : OptionNone(txb);
 
         if (passport) {
             p.object = txb.moveCall({
                 target:protocol.ProgressFn('new_with_passport') as FnCallType,
-                arguments: [passport, Protocol.TXB_OBJECT(txb, machine), Protocol.TXB_OBJECT(txb, permission)],
+                arguments: [passport, t, Protocol.TXB_OBJECT(txb, machine), Protocol.TXB_OBJECT(txb, permission)],
             })    
         } else {
             p.object = txb.moveCall({
                 target:protocol.ProgressFn('new') as FnCallType,
-                arguments: [Protocol.TXB_OBJECT(txb, machine), Protocol.TXB_OBJECT(txb, permission)],
+                arguments: [t, Protocol.TXB_OBJECT(txb, machine), Protocol.TXB_OBJECT(txb, permission)],
             })    
         }
         return p
@@ -91,7 +111,7 @@ export class Progress {
         if (!IsValidName(name)) {
             ERROR(Errors.IsValidName, 'name')
         }
-        if (!addresses || addresses.length > Progress.MAX_NAMED_OPERATOR_COUNT || !IsValidArray(addresses, IsValidAddress)) {
+        if (addresses.length > Progress.MAX_NAMED_OPERATOR_COUNT || !IsValidArray(addresses, IsValidAddress)) {
             ERROR(Errors.InvalidParam, 'addresses')
         }
 
@@ -99,14 +119,14 @@ export class Progress {
         if (passport) {
             txb.moveCall({
                 target:this.protocol.ProgressFn('namedOperator_set_with_passport') as FnCallType,
-                arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), 
+                arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(name), 
                     txb.pure(array_unique(addresses), 'vector<address>'), 
                 Protocol.TXB_OBJECT(txb, this.machine), Protocol.TXB_OBJECT(txb, this.permission)],
             })  
         } else {
             txb.moveCall({
                 target:this.protocol.ProgressFn('namedOperator_set') as FnCallType,
-                arguments: [Protocol.TXB_OBJECT(txb, this.object), txb.pure(name, BCS.STRING), 
+                arguments: [Protocol.TXB_OBJECT(txb, this.object), txb.pure(name), 
                     txb.pure(array_unique(addresses), 'vector<address>'), 
                 Protocol.TXB_OBJECT(txb, this.machine), Protocol.TXB_OBJECT(txb, this.permission)],
             })  
@@ -132,7 +152,6 @@ export class Progress {
                     Protocol.TXB_OBJECT(txb, this.machine), Protocol.TXB_OBJECT(txb, this.permission)],
             })   
         } 
-        
     }
     set_context_repository(repository?:RepositoryObject, passport?:PassportObject)  {
         if (repository && !Protocol.IsValidObjects([repository])) {
@@ -190,45 +209,52 @@ export class Progress {
             })           
         }
     }
+    parent_none(passport?:PassportObject) {
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target:this.protocol.ProgressFn('parent_none_with_passport') as FnCallType,
+                arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), 
+                    Protocol.TXB_OBJECT(txb, this.machine), Protocol.TXB_OBJECT(txb, this.permission)],
+            }) 
+        } else {
+            txb.moveCall({
+                target:this.protocol.ProgressFn('parent_none') as FnCallType,
+                arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
+                    Protocol.TXB_OBJECT(txb, this.permission)],
+            }) 
+        }
+    }
 
     parent(parent:ParentProgress, passport?:PassportObject)  {
         if (!IsValidAddress(parent.parent_id) || !IsValidInt(parent.parent_session_id)) {
             ERROR(Errors.InvalidParam, 'parent')
         }
+        if (!parent.next_node || !parent.forward) {
+            ERROR(Errors.InvalidParam, 'parent')
+        }
 
         let txb = this.protocol.CurrentSession();
         if (passport) {
-            if (parent.parent_id) {
-                txb.moveCall({
-                    target:this.protocol.ProgressFn('parent_set_with_passport') as FnCallType,
-                    arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
-                        txb.pure(parent.parent_id, BCS.ADDRESS), 
-                        txb.pure(parent.parent_session_id, BCS.U64), 
-                        Protocol.TXB_OBJECT(txb, this.permission)],
-                })  
-            } else {
-                txb.moveCall({
-                    target:this.protocol.ProgressFn('parent_none_with_passport') as FnCallType,
-                    arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), 
-                        Protocol.TXB_OBJECT(txb, this.machine), Protocol.TXB_OBJECT(txb, this.permission)],
-                }) 
-            }
+            txb.moveCall({
+                target:this.protocol.ProgressFn('parent_set_with_passport') as FnCallType,
+                arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
+                    txb.pure(parent.parent_id, BCS.ADDRESS), 
+                    txb.pure(parent.parent_session_id, BCS.U64), 
+                    txb.pure(parent.next_node),
+                    txb.pure(parent.forward),
+                    Protocol.TXB_OBJECT(txb, this.permission)],
+            })  
         } else {
-            if (parent.parent_id) {
-                txb.moveCall({
-                    target:this.protocol.ProgressFn('parent_set') as FnCallType,
-                    arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
-                        txb.pure(parent.parent_id, BCS.ADDRESS), 
-                        txb.pure(parent.parent_session_id, BCS.U64), 
-                        Protocol.TXB_OBJECT(txb, this.permission)],
-                })  
-            } else {
-                txb.moveCall({
-                    target:this.protocol.ProgressFn('parent_none') as FnCallType,
-                    arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
-                        Protocol.TXB_OBJECT(txb, this.permission)],
-                }) 
-            } 
+            txb.moveCall({
+                target:this.protocol.ProgressFn('parent_set') as FnCallType,
+                arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
+                    txb.pure(parent.parent_id, BCS.ADDRESS), 
+                    txb.pure(parent.parent_session_id, BCS.U64), 
+                    txb.pure(parent.next_node),
+                    txb.pure(parent.forward),
+                    Protocol.TXB_OBJECT(txb, this.permission)],
+            })  
         }
     }
 
@@ -251,15 +277,15 @@ export class Progress {
             txb.moveCall({
                 target:this.protocol.ProgressFn('next_with_passport') as FnCallType,
                 arguments: [passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), 
-                    txb.pure(next.next_node_name, BCS.STRING), 
-                    txb.pure(next.forward, BCS.STRING), diliverable, sub, 
+                    txb.pure(next.next_node_name), 
+                    txb.pure(next.forward), diliverable, sub, 
                     Protocol.TXB_OBJECT(txb, this.permission)],
             })    
         } else {
             txb.moveCall({
                 target:this.protocol.ProgressFn('next') as FnCallType,
-                arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), txb.pure(next.next_node_name, BCS.STRING), 
-                    txb.pure(next.forward, BCS.STRING), diliverable, sub, Protocol.TXB_OBJECT(txb, this.permission)],
+                arguments: [Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.machine), txb.pure(next.next_node_name), 
+                    txb.pure(next.forward), diliverable, sub, Protocol.TXB_OBJECT(txb, this.permission)],
             })               
         }
     }
@@ -276,9 +302,41 @@ export class Progress {
                 txb.pure(next.forward), txb.pure(hold, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
         })  
     }
-    static MAX_NAMED_OPERATOR_COUNT = 100;
+    static rpc_de_sessions = (session: any) : Session[] => {
+        let sessions : Session[] = [];
+        session?.fields?.contents?.forEach((v:any) => {
+            var s:Session = {next_node: v.fields.key, holders:[], weights:v.fields.value.fields.weights, threshold:v.fields.value.fields.threshold};
+            v.fields.value.fields.forwards.fields.contents.forEach((i:any) => {
+              s.holders.push({forward:i.fields.key, accomplished:i.fields.value.fields.accomplished, 
+                who:i.fields.value.fields.who, deliverables:i.fields.value.fields.deliverables ?? undefined,
+                sub_progress: i.fields.value.fields.sub_progress ?? undefined
+              })
+            })
+            sessions.push(s);
+        })
+        return sessions;
+    }
+
+    static rpc_de_history = (fields: any) : Session[] => {
+        let sessions : Session[] = [];
+        fields?.forEach((v:any) => {
+          const next_node = v.data.content.fields.value.fields.next_node;
+          v.data.content.fields.value.fields.session.fields.contents.forEach((i:any) => {
+            var s:Session = {id:v.data.content.fields.name,
+                node:v.data.content.fields.value.fields.node, next_node: i.fields.key, holders:[], 
+              weights:i.fields.value.fields.weights, threshold:i.fields.value.fields.threshold, bComplete:i.fields.key === next_node};
+              i.fields.value.fields.forwards.fields.contents.forEach((k:any) => {
+              s.holders.push({forward:k.fields.key, who:k.fields.value.fields.who, accomplished:k.fields.value.fields.accomplished,
+                sub_progress:k.fields.value.fields.sub_progress ?? undefined, deliverables:k.fields.value.fields.deliverables ?? undefined});
+            })
+            sessions.push(s);
+          })
+        })
+        return sessions;
+    }
+
+    static MAX_NAMED_OPERATOR_COUNT = 20;
     static IsValidProgressNext = (next:ProgressNext) => {
         return IsValidName(next.forward)  && IsValidName(next.next_node_name);
     }
-    
 }