wowok_agent 0.0.1

package/src/call/arbitration.ts

@@ -0,0 +1,169 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Treasury, 
+    Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, WitnessFill
+} from 'wowok';
+import { OBJECT_QUERY, ObjectArbitration, } from '../objects';
+import { CallBase } from "./call";
+
+export class CallArbitration extends CallBase {
+    type_parameter: string;
+    permission_new?: string;
+    description?: string;
+    bPaused?: boolean;
+    endpoint?: string;
+    fee?: string;
+    fee_treasury?: string;
+    usage_guard?: string;
+    voting_guard?: {op:'add' | 'set'; data:VotingGuard[]} | {op:'remove', guards:string[]} | {op:'removeall'};
+    arb_new?: {data: Dispute; guard?:string | 'fetch'}; // dispute an order, and a new Arb launched.
+    arb_withdraw_fee?: {arb:string; data:WithdrawFee};
+    arb_vote?: Vote;
+    arb_arbitration?: Feedback;
+    constructor(type_parameter:string, object: string | 'new' = 'new') { 
+        super(object) 
+        this.type_parameter = type_parameter;
+    }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        if (!this.type_parameter) ERROR(Errors.InvalidParam, 'type_parameter')
+
+        var checkOwner = false; const guards : string[] = [];
+        const perms : PermissionIndexType[] = [];  var obj: ObjectArbitration | undefined ;
+
+        if (this?.permission && IsValidAddress(this.permission)) {
+            if (this?.object === 'new') {
+                perms.push(PermissionIndex.arbitration)
+            }
+            if (this?.permission_new !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.description !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.arbitration_description)
+            }
+            if (this?.bPaused !== undefined) {
+                perms.push(PermissionIndex.arbitration_pause)
+            }
+            if (this?.endpoint == undefined) { // publish is an irreversible one-time operation 
+                perms.push(PermissionIndex.arbitration_endpoint)
+            }
+            if (this?.fee !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.arbitration_fee)
+            }
+            if (this?.fee_treasury !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.arbitration_treasury)
+            }
+            if (this?.usage_guard !== undefined) {
+                perms.push(PermissionIndex.arbitration_guard)
+            }
+            if (this?.voting_guard !== undefined) {
+                perms.push(PermissionIndex.arbitration_voting_guard)
+            }
+            if (this?.arb_arbitration !== undefined) {
+                perms.push(PermissionIndex.arbitration_arbitration)
+            }
+            if (this?.arb_new?.guard !== undefined) {
+                if (IsValidAddress(this.arb_new.guard)) {
+                    guards.push(this.arb_new.guard)
+                } else {
+                    if (!obj) {
+                        const r = await OBJECT_QUERY.objects({objects:[this.object], showContent:true});
+                        if (r?.objects && r.objects[0].type === 'Treasury') {
+                            obj = r.objects[0] as ObjectArbitration;
+                        }
+                    }
+                    if (obj?.usage_guard) {
+                        guards.push(obj?.usage_guard)
+                    }
+                }
+            }
+            if (this?.arb_vote !== undefined) {
+                perms.push(PermissionIndex.treasury_receive)
+            }
+            if (typeof(this?.arb_vote?.voting_guard) === 'string' && IsValidAddress(this?.arb_vote?.voting_guard)) {
+                guards.push(this?.arb_vote?.voting_guard)
+            }
+
+            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+        }
+        return this.exec(account);
+    }
+    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Arbitration | undefined ; let permission: any; let withdraw_treasury:any;
+        if (this.object === 'new' && this?.type_parameter) {
+            if (!this?.permission || !IsValidAddress(this?.permission)) {
+                permission = Permission.New(txb, '');
+            }
+            if (!this?.fee_treasury || !IsValidAddress(this?.fee_treasury)) {
+                withdraw_treasury = Treasury.New(txb, this?.type_parameter, permission ?? this?.permission, '', permission?undefined:passport);
+            }
+            obj = Arbitration.New(txb, this.type_parameter, permission ?? this?.permission, this?.description??'', 
+                BigInt(this?.fee ?? 0), withdraw_treasury??this.fee_treasury, permission?undefined:passport);
+        } else {
+            if (IsValidAddress(this.object) && this.type_parameter && this.permission && IsValidAddress(this?.permission)) {
+                obj = Arbitration.From(txb, this.type_parameter, this.permission, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description, passport);
+            }
+            if (this?.bPaused !== undefined) {
+                obj?.pause(this.bPaused, passport);
+            }
+            if (this?.endpoint !== undefined) {
+                obj?.set_endpoint(this.endpoint, passport)
+            }
+            if (this?.fee !== undefined && this.object !== 'new') {
+                obj?.set_fee(BigInt(this.fee), passport)
+            }
+            if (this.fee_treasury !== undefined && this.object !== 'new') {
+                obj?.set_withdrawTreasury(this.fee_treasury, passport)
+            }
+            if (this.usage_guard !== undefined) {
+                obj?.set_guard(this.usage_guard, passport)
+            }
+            if (this?.voting_guard !== undefined) {
+                switch (this.voting_guard.op) {
+                    case 'add':
+                        obj?.add_voting_guard(this.voting_guard.data, passport)
+                        break;
+                    case 'remove':
+                        obj?.remove_voting_guard(this.voting_guard.guards, false, passport)
+                        break;
+                    case 'set':
+                        obj?.remove_voting_guard([], true, passport)
+                        obj?.add_voting_guard(this.voting_guard.data, passport)
+                        break;
+                    case 'removeall':
+                        obj?.remove_voting_guard([], true, passport)
+                        break;
+                }
+            }
+            
+            if (this?.arb_new !== undefined) {
+                obj?.dispute(this.arb_new.data, passport)
+            }
+            if (this?.arb_arbitration !== undefined) {
+                obj?.arbitration(this.arb_arbitration, passport)
+            }
+            if (this?.arb_vote !== undefined) {
+                obj?.vote(this.arb_vote, passport)
+            }
+            if (this?.arb_withdraw_fee !== undefined) {
+                obj?.withdraw_fee(this.arb_withdraw_fee.arb, this.arb_withdraw_fee.data, passport)
+            }
+            if (this?.permission_new !== undefined) {
+                obj?.change_permission(this.permission_new);
+            }
+            if (withdraw_treasury) {
+                withdraw_treasury.launch();
+            }
+            if (permission) {
+                permission.launch();
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}

package/src/call/call.ts

@@ -0,0 +1,133 @@
+/**
+ * Provide a this interface for AI
+ * Operation sequence Priority: common operation > Guard change > permission change
+ * Recommended: Changes to guard and permission are committed on-chain separately to avoid permission dependencies for other operations.
+ */
+
+import { Protocol, TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, Errors, ERROR, Permission, 
+    PermissionIndexType, GuardParser, Passport, WitnessFill
+} from 'wowok';
+import { PERMISSION_QUERY } from '../permission';
+import { Account } from '../account';
+import { ObjectBase } from '../objects';
+
+
+export interface ResponseData extends ObjectBase {
+    change:'created' | 'mutated' | string;
+} 
+
+export class CallBase {
+    object: string | 'new' ;
+    permission?: string;
+    constructor(object: string | 'new' = 'new') {
+        this.object = object;
+    }
+    // operation implementation for a call
+    protected async operate(txb:TransactionBlock, passport?:PassportObject) {};
+    
+    // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call; 
+    // return ResponseData when the call has completed; 
+    // throw an exception when errors.
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>  { return undefined };
+    async call_with_witness (guards: string[], fill?: WitnessFill[], account?:string) : Promise<CallResponse | undefined> {
+        if (guards.length > 0) {         // prepare passport
+            const p: GuardParser | undefined = await GuardParser.Create([...guards]);
+            const pair = Account.Instance().get_pair(account, true);
+            if (!pair) ERROR(Errors.Fail, 'account invalid')
+
+            if (p) {
+                const query = await p.done(fill);
+                if (query) {
+                    const txb = new TransactionBlock();
+                    const passport = new Passport(txb, query!);   
+                    this.operate(new TransactionBlock(), passport?.get_object())
+                    passport.destroy();
+
+                    return await Protocol.Client().signAndExecuteTransaction({
+                        transaction: txb, 
+                        signer: pair!,
+                        options:{showObjectChanges:true},
+                    });
+                }
+            } else {
+                ERROR(Errors.Fail, 'guard finish_passport')
+            }
+        } 
+    }
+
+    protected async check_permission_and_call (permission:string, permIndex: PermissionIndexType[], guards_needed: string[],
+        checkOwner?:boolean, checkAdmin?:boolean, account?:string) : Promise<WitnessFill[] | CallResponse>  {
+        var guards : string[] = [];
+        const pair = Account.Instance().get_pair(account, true);
+        if (!pair) ERROR(Errors.Fail, 'account invalid')
+
+        if (permIndex.length > 0 || checkOwner) {
+            const p = await PERMISSION_QUERY.permission({permission_object:permission, address:pair!.toSuiAddress()});
+            if (checkOwner && !p.owner) ERROR(Errors.noPermission, 'owner');
+            if (checkAdmin && !p.admin) ERROR(Errors.noPermission, 'admin');
+
+            permIndex.forEach(v => {
+                const r = Permission.HasPermission(p, v);
+                if (!r?.has) ERROR(Errors.noPermission, v);
+                if (r?.guard) guards.push(r.guard)
+            })       
+        }
+        if (guards_needed.length > 0) {
+            guards = guards.concat(guards_needed);
+        }
+
+        if (guards.length > 0) {         // prepare passport
+            const p: GuardParser | undefined = await GuardParser.Create([...guards]);
+            const futures = p ? p.future_fills() : []; 
+
+            if (!p) ERROR(Errors.Fail, 'guard parse')
+
+            if (p && futures.length === 0) {
+                const query = await p.done();
+                if (query) {
+                    const txb = new TransactionBlock();
+                    const passport = new Passport(txb, query!);   
+                    this.operate(new TransactionBlock(), passport?.get_object())
+                    passport.destroy();
+
+                    return await Protocol.Client().signAndExecuteTransaction({
+                        transaction: txb, 
+                        signer: pair!,
+                        options:{showObjectChanges:true},
+                    });
+                }
+            } 
+            
+            return p!.future_fills();
+        } else { // no passport needed
+            return this.exec()
+        }
+    }
+    protected async exec (account?:string) : Promise<CallResponse> {
+        const pair = Account.Instance().get_pair(account, true);
+        if (!pair) ERROR(Errors.Fail, 'account invalid')
+
+        const txb = new TransactionBlock();
+        this.operate(txb);
+        return await Protocol.Client().signAndExecuteTransaction({
+            transaction: txb, 
+            signer: pair!,
+            options:{showObjectChanges:true},
+        });
+    }
+
+    static ResponseData(response: CallResponse | undefined ) : ResponseData[] {
+        const res : ResponseData[] = [];
+        response?.objectChanges?.forEach(v => {
+            const type_raw: string | undefined = (v as any)?.objectType;
+            const type:string | undefined = type_raw ? Protocol.Instance().object_name_from_type_repr(type_raw) : undefined;
+            if (type) {
+                res.push({type:type, type_raw:type_raw, object:(v as any)?.objectId, version:(v as any)?.version,
+                    owner:(v as any)?.owner, change:v.type
+                })
+            }
+        })
+        return res;
+    }
+}

package/src/call/demand.ts

@@ -0,0 +1,133 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, PermissionIndex, UserDefinedIndex,
+    PermissionIndexType, Demand,  WitnessFill
+} from 'wowok';
+import { OBJECT_QUERY, ObjectDemand } from '../objects';
+import { CallBase } from "./call";
+
+export class CallDemand extends CallBase {
+    permission_new?: string;
+    type_parameter: string;
+    guard?: {address:string; service_id_in_guard?:number};
+    description?: string;
+    time_expire?: {op: 'duration'; minutes:number} | {op:'set'; time:number};
+    bounty?: {op:'add'; object?:string; balance:string} | {op:'refund'} | {op:'reward'; service:string};
+    present?: {service: string | number; recommend_words:string; service_pay_type:string, guard?:string | 'fetch'}; // guard is the present guard of Demand
+    reward?: string; // rerward the service
+    refund?: boolean;
+    constructor(type_parameter:string, object: string | 'new' = 'new') { 
+        super(object)
+        this.type_parameter = type_parameter 
+    }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        if (!this.type_parameter) ERROR(Errors.InvalidParam, 'type_parameter')
+        var checkOwner = false; const guards : string[] = [];
+        const perms : PermissionIndexType[] = []; 
+
+        if (this?.permission && IsValidAddress(this.permission)) {
+            if (this?.object === 'new') {
+                perms.push(PermissionIndex.demand)
+            }
+            if (this?.permission_new !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.description !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.demand_description)
+            }
+            if (this?.time_expire !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.demand_expand_time)
+            }
+            if (this?.guard !== undefined) {
+                perms.push(PermissionIndex.demand_guard)
+            }
+            if (this?.reward !== undefined) {
+                perms.push(PermissionIndex.demand_yes)
+            }
+            if (this?.refund) {
+                perms.push(PermissionIndex.demand_refund)
+            }
+            if (this?.present?.guard !== undefined) {
+                if (IsValidAddress(this.present.guard)) {
+                    guards.push(this.present.guard)
+                } else if (IsValidAddress(this?.object)) {
+                    const r = await OBJECT_QUERY.objects({objects:[this.object], showContent:true});
+                    if (r?.objects && r?.objects[0]?.type === 'Demand') {
+                        const obj = (r?.objects[0] as ObjectDemand);
+                        if (obj?.guard) {
+                            guards.push(obj?.guard.object);
+                        }
+                    }
+                }
+            }
+            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+        }
+        return this.exec(account);
+    }
+    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Demand | undefined ; let permission: any;
+
+        if (this.object === 'new') {
+            if (!this?.permission || !IsValidAddress(this?.permission)) {
+                permission = Permission.New(txb, '');
+            }
+            
+            if (this.time_expire !== undefined) {
+                obj = Demand.New(txb, this.type_parameter, this.time_expire?.op === 'duration' ? true : false, 
+                    this.time_expire?.op === 'duration' ? this.time_expire.minutes : this.time_expire?.time,
+                    permission ? permission.get_object(): this?.permission, this?.description??'', permission?undefined:passport)
+            } else {
+                obj = Demand.New(txb, this.type_parameter, true, 30*24*60, // 30days default
+                    permission ? permission.get_object(): this?.permission, this?.description??'', permission?undefined:passport)       
+            }
+        } else {
+            if (IsValidAddress(this.object) && this.type_parameter && this.permission && IsValidAddress(this?.permission)) {
+                obj = Demand.From(txb, this.type_parameter, this.permission, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description, passport);
+            }
+            if (this?.time_expire !== undefined && this.object !== 'new') {
+                obj?.expand_time(this.time_expire.op === 'duration' ? true : false, 
+                    this.time_expire.op === 'duration' ? this.time_expire.minutes : this.time_expire.time, passport)
+            }
+            if (this?.bounty !== undefined) {
+                if (this.bounty.op === 'add') {
+                    let deposit : any | undefined; let b = BigInt(this.bounty.balance);
+                    if (b > BigInt(0)) {
+                        if (this.type_parameter === '0x2::sui::SUI' || this.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
+                            deposit = txb.splitCoins(txb.gas, [b])[0];
+                        } else if (this?.bounty?.object) {
+                            deposit = txb.splitCoins(this.bounty.object, [b])[0];
+                        }
+                        if (deposit) {
+                            obj?.deposit(deposit);                              
+                        }
+                    }
+                } else if (this.bounty.op === 'refund') {
+                    obj?.refund(passport);
+                } else if (this.bounty.op === 'reward') {
+                    obj?.yes(this.bounty.service, passport);
+                }
+            }
+            if (this?.present !== undefined) {
+                //@ demand guard and its passport, if set
+                obj?.present(this.present.service, this.present.service_pay_type, this.present.recommend_words, passport);
+            }
+            if (this?.guard !== undefined) {
+                obj?.set_guard(this.guard.address, this.guard?.service_id_in_guard ?? undefined, passport)
+            }
+            if (this?.permission_new !== undefined ) {
+                obj?.change_permission(this.permission_new);
+            }
+            if (permission) {
+                permission.launch();
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}

package/src/call/machine.ts

@@ -0,0 +1,209 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, WitnessFill,
+    PermissionIndexType, Machine, Machine_Forward, Machine_Node,  Deliverable, ParentProgress, Progress, ProgressNext,
+} from 'wowok';
+import { CallBase } from "./call";
+import { Account } from '../account';
+
+export class CallMachine extends CallBase { //@ todo self-owned node operate
+    permission_new?: string;
+    bPaused?: boolean;
+    bPublished?: boolean;
+    consensus_repository?: {op:'set' | 'add' | 'remove' ; repositories:string[]} | {op:'removeall'};
+    description?: string;
+    endpoint?: string;
+    clone_new?: boolean;
+    nodes?: {op: 'add'; data: Machine_Node[]} | {op: 'remove'; names: string[], bTransferMyself?:boolean} 
+        | {op:'rename node'; data:{old:string; new:string}[]} | {op:'add from myself'; addresses: string[]}
+        | {op:'remove pair'; pairs: {prior_node_name:string; node_name:string}[]}
+        | {op:'add forward'; data: {prior_node_name:string; node_name:string; forward:Machine_Forward; threshold?:number; old_need_remove?:string}[]}
+        | {op:'remove forward'; data:{prior_node_name:string; node_name:string; forward_name:string}[]}
+    progress_new?: {task_address?:string; };
+    progress_context_repository?: {progress:string; repository:string};
+    progress_parent?: {progress:string, parent?:ParentProgress};
+    progress_task?: {progress:string; task:string};
+    progress_namedOperator?: {progress:string; data:{name:string, operator:string[]}[]};
+    progress_hold?: {progress:string; data:ProgressNext; bHold:boolean; adminUnhold?:boolean};
+    progress_next?: {progress:string; data:ProgressNext; deliverable:Deliverable; guard?:string | 'fetch'};
+    constructor(object: string | 'new' = 'new') { super(object) }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        var checkOwner = false; const guards : string[] = [];
+        const perms : PermissionIndexType[] = []; 
+
+        if (this?.permission && IsValidAddress(this.permission)) {
+            if (this?.object === 'new') {
+                perms.push(PermissionIndex.machine)
+            }
+            if (this?.permission_new !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.description !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.machine_description)
+            }
+            if (this?.bPaused !== undefined) {
+                perms.push(PermissionIndex.machine_pause)
+            }
+            if (this?.bPublished) { // publish is an irreversible one-time operation 
+                perms.push(PermissionIndex.machine_publish)
+            }
+            if (this?.endpoint !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.machine_endpoint)
+            }
+            if (this?.consensus_repository !== undefined) {
+                perms.push(PermissionIndex.machine_repository)
+            }
+            if (this?.clone_new !== undefined) {
+                perms.push(PermissionIndex.machine_clone)
+            }
+            if (this?.nodes !== undefined) {
+                perms.push(PermissionIndex.machine_node)
+            }
+            if (this?.progress_new !== undefined) {
+                perms.push(PermissionIndex.progress)
+            }
+            if (this?.progress_context_repository !== undefined) {
+                perms.push(PermissionIndex.progress_context_repository)
+            }
+            if (this?.progress_namedOperator !== undefined) {
+                perms.push(PermissionIndex.progress_namedOperator)
+            }
+            if (this?.progress_parent !== undefined) {
+                perms.push(PermissionIndex.progress_parent)
+            }
+            if (this?.progress_task !== undefined) {
+                perms.push(PermissionIndex.progress_bind_task)
+            }
+            if (this?.progress_hold !== undefined) {
+                if (this.progress_hold.adminUnhold) {
+                    perms.push(PermissionIndex.progress_unhold)
+                } 
+            }
+            if (this?.progress_next?.guard !== undefined) {
+                if (IsValidAddress(this?.progress_next?.guard)) {
+                    guards.push(this?.progress_next?.guard)
+                } else if (this?.object && IsValidAddress(this.object)) { // fetch guard
+                    const guard = await Progress.QueryForwardGuard(this?.progress_next.progress, this.object, 
+                        Account.Instance().get_address() ?? '0xe386bb9e01b3528b75f3751ad8a1e418b207ad979fea364087deef5250a73d3f', 
+                        this.progress_next.data.next_node_name, this.progress_next.data.forward);
+                    if (guard) {
+                        guards.push(guard)
+                    }
+                }
+            }
+
+            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+        }
+        return this.exec(account);
+    }
+
+    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Machine | undefined ; let permission: any;
+        if (this.object === 'new') {
+            if (!this?.permission || !IsValidAddress(this?.permission)) {
+                permission = Permission.New(txb, '');
+            }
+            obj = Machine.New(txb, permission ?? this?.permission, this?.description??'', this?.endpoint ?? '', permission?undefined:passport);
+        } else {
+            if (IsValidAddress(this.object) && this.permission && IsValidAddress(this?.permission)) {
+                obj = Machine.From(txb, this.permission, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description, passport);
+            }
+            if (this?.endpoint !== undefined && this.object !== 'new') {
+                obj?.set_endpoint(this.endpoint, passport)
+            }
+            if (this?.bPaused !== undefined) {
+                obj?.pause(this.bPaused, passport)
+            }
+            if (this?.bPublished ) {
+                obj?.publish(passport)
+            }
+            if (this?.clone_new) {
+                obj?.clone(true, passport)
+            }
+            if (this?.consensus_repository !== undefined) {
+                switch (this.consensus_repository.op) {
+                    case 'add': 
+                        this.consensus_repository.repositories.forEach(v=>obj?.add_repository(v, passport)) ;
+                        break;
+                    case 'remove': 
+                        obj?.remove_repository(this.consensus_repository.repositories, false, passport);
+                        break;
+                    case 'removeall': 
+                        obj?.remove_repository([], true, passport);
+                        break;
+                    case 'set':
+                        obj?.remove_repository([], true, passport);
+                        this.consensus_repository.repositories.forEach(v=>obj?.add_repository(v, passport)) ;
+                        break;
+                }
+            }
+            if (this?.nodes !== undefined) {
+                switch (this?.nodes?.op) {
+                    case 'add':
+                        obj?.add_node(this.nodes.data, passport)
+                        break;
+                    case 'remove':
+                        obj?.remove_node(this.nodes.names, this.nodes?.bTransferMyself, passport)
+                        break;
+                    case 'rename node':
+                        this.nodes.data.forEach(v => obj?.rename_node(v.old, v.new, passport));
+                        break;
+                    case 'add from myself':
+                        obj?.add_node2(this.nodes.addresses, passport);
+                        break;
+                    case 'add forward':
+                        this.nodes.data.forEach(v => obj?.add_forward(v.prior_node_name, v.node_name, v.forward, v.threshold, v.old_need_remove, passport))
+                        break;
+                    case 'remove forward':
+                        this.nodes.data.forEach(v => obj?.remove_forward(v.prior_node_name, v.node_name, v.forward_name, passport))
+                        break;
+                    }
+            }
+            if (this?.progress_new !== undefined) {
+                Progress?.New(txb, this?.object, permission??this?.permission, this?.progress_new.task_address, passport).launch();
+            }
+            if (this?.progress_context_repository !== undefined) {
+                Progress.From(txb, this?.object, permission??this?.permission, this?.progress_context_repository.progress)
+                    .set_context_repository(this?.progress_context_repository.repository, passport)
+            }
+            if (this?.progress_namedOperator !== undefined) {
+                const p = Progress.From(txb, this?.object, permission??this?.permission, this?.progress_namedOperator.progress);
+                this.progress_namedOperator.data.forEach(v => p.set_namedOperator(v.name, v.operator, passport));
+            }
+            if (this?.progress_parent !== undefined) {
+                if (this.progress_parent.parent) {
+                    Progress.From(txb, this?.object, permission??this?.permission, this?.progress_parent.progress).parent(this.progress_parent.parent);
+                } else {
+                    Progress.From(txb, this?.object, permission??this?.permission, this?.progress_parent.progress).parent_none();
+                }
+            }
+            if (this?.progress_task !== undefined) {
+                Progress.From(txb, this?.object, permission??this?.permission, this?.progress_task.progress).bind_task(this.progress_task.task, passport)
+            }
+            if (this?.progress_hold !== undefined) {
+                if (this?.progress_hold.adminUnhold) {
+                    Progress.From(txb, this?.object, permission??this?.permission, this?.progress_hold.progress).unhold(this.progress_hold.data, passport)
+                } else {
+                    Progress.From(txb, this?.object, permission??this?.permission, this?.progress_hold.progress).hold(this.progress_hold.data, this.progress_hold.bHold)
+                }
+            }
+            if (this?.progress_next !== undefined) {
+                Progress.From(txb, this?.object, permission??this?.permission, this?.progress_next.progress).next(this.progress_next.data, this.progress_next.deliverable, passport)
+            }
+            if (this?.permission_new !== undefined ) {
+                obj?.change_permission(this.permission_new);
+            }
+            if (permission) {
+                permission.launch();
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}