wowok_agent 0.1.13 → 0.1.16

package/dist/src/call/guard.js

@@ -0,0 +1,244 @@
+/**
+ *  generate and launch a guard
+ */
+import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, concatenate, Protocol, hasDuplicates, insertAtHead, IsValidDesription, IsValidGuardIdentifier } from "wowok";
+import { CallBase } from "./base";
+export class CallGuard extends CallBase {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async call(account) {
+        return await this.exec(account);
+    }
+    async operate(txb, passport, account) {
+        if (!this.data?.root) {
+            ERROR(Errors.InvalidParam, 'guard root node invalid');
+        }
+        if (!IsValidDesription(this.data?.description)) {
+            ERROR(Errors.IsValidDesription, 'build_guard - ' + this.data.description);
+        }
+        // check const
+        this.data?.table?.forEach(v => {
+            if (!IsValidU8(v.identifier) || v.identifier < 1)
+                ERROR(Errors.InvalidParam, 'table.identifer invalid');
+            if (!v.bWitness && v.value === undefined)
+                ERROR(Errors.InvalidParam, 'table.value');
+        });
+        if (this.data?.table && hasDuplicates(this.data?.table?.map(v => v.identifier))) {
+            ERROR(Errors.InvalidParam, 'table.identifer duplicates');
+        }
+        // check root
+        var output = [];
+        buildNode(this.data.root, ValueType.TYPE_BOOL, this.data?.table ?? [], output);
+        const bytes = concatenate(Uint8Array, ...output);
+        const obj = txb.moveCall({
+            target: Protocol.Instance().guardFn('new'),
+            arguments: [txb.pure.string(this.data.description), txb.pure.vector('u8', [].slice.call(bytes.reverse()))],
+        });
+        this.data?.table?.forEach((v) => {
+            if (v.bWitness) {
+                const n = new Uint8Array(1);
+                n.set([v.value_type], 0);
+                txb.moveCall({
+                    target: Protocol.Instance().guardFn("constant_add"),
+                    arguments: [txb.object(obj), txb.pure.u8(v.identifier), txb.pure.bool(true), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(false)]
+                });
+            }
+            else {
+                const tmp = Uint8Array.from(Bcs.getInstance().ser(v.value_type, v.value));
+                const n = insertAtHead(tmp, v.value_type);
+                txb.moveCall({
+                    target: Protocol.Instance().guardFn("constant_add"),
+                    arguments: [txb.object(obj), txb.pure.u8(v.identifier), txb.pure.bool(false), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(false)]
+                });
+            }
+        });
+        const addr = txb.moveCall({
+            target: Protocol.Instance().guardFn("create"),
+            arguments: [txb.object(obj)]
+        });
+        await this.new_with_mark(txb, addr, this.data?.namedNew, account);
+    }
+}
+//export const MAX_CHILD_NODE_COUNT = 6;
+const buildNode = (guard_node, type_required, table, output) => {
+    const node = guard_node;
+    if (node?.identifier !== undefined) {
+        const f = table.find(v => v.identifier === node.identifier);
+        if (f) {
+            checkType(f.value_type, type_required, node);
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.identifier));
+        }
+        else {
+            ERROR(Errors.InvalidParam, 'node identifier - ' + JSON.stringify(node));
+        }
+    }
+    else if (node?.query !== undefined) {
+        var q;
+        if (typeof (node.query) === 'string') {
+            q = GUARD_QUERIES.find(v => v[1] === node.query);
+        }
+        else if (typeof (node.query) === 'number') {
+            q = GUARD_QUERIES.find(v => v[2] === node.query);
+        }
+        if (!q)
+            ERROR(Errors.InvalidParam, 'query invalid - ' + node?.query);
+        checkType(q[4], type_required, node); // Return type checking
+        if ((q[3]).length === node.parameters.length) {
+            for (let i = node.parameters.length - 1; i >= 0; --i) { // stack: first in, last out
+                buildNode(node.parameters[i], q[3][i], table, output); // Recursive check
+            }
+        }
+        else {
+            ERROR(Errors.InvalidParam, 'node query parameters length not match - ' + JSON.stringify(node));
+        }
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_QUERY)); // QUERY TYPE + addr + cmd
+        if (typeof (node.object) === 'string') {
+            if (!IsValidAddress(node.object)) {
+                ERROR(Errors.InvalidParam, 'node object from address string - ' + JSON.stringify(node));
+            }
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ValueType.TYPE_ADDRESS));
+            output.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, node.object)); // object address             
+        }
+        else {
+            const f = table.find(v => v.identifier === node.object);
+            if (f) {
+                checkType(f.value_type, ValueType.TYPE_ADDRESS, node);
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.object)); // object id
+            }
+            else {
+                ERROR(Errors.InvalidParam, 'node object from identifier - ' + JSON.stringify(node));
+            }
+        }
+        output.push(Bcs.getInstance().ser('u16', q[2])); // cmd(u16)
+    }
+    else if (node?.logic !== undefined) {
+        checkType(ValueType.TYPE_BOOL, type_required, node); // bool
+        switch (node?.logic) {
+            case OperatorType.TYPE_LOGIC_AND:
+            case OperatorType.TYPE_LOGIC_OR:
+                if (node.parameters.length < 2)
+                    ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2' + JSON.stringify(node));
+                node.parameters.reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+            case OperatorType.TYPE_LOGIC_NOT:
+                if (node.parameters.length !== 1)
+                    ERROR(Errors.InvalidParam, 'node logic parameters length must be 1' + JSON.stringify(node));
+                node.parameters.reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                break;
+            case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
+            case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
+            case OperatorType.TYPE_LOGIC_AS_U256_LESSER:
+            case OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL:
+            case OperatorType.TYPE_LOGIC_AS_U256_EQUAL:
+                if (node.parameters.length < 2)
+                    ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2' + JSON.stringify(node));
+                node.parameters.reverse().forEach(v => buildNode(v, 'number', table, output));
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+            case OperatorType.TYPE_LOGIC_EQUAL:
+                if (node.parameters.length < 2)
+                    ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2' + JSON.stringify(node));
+                var any_type = 'variable';
+                node.parameters.reverse().forEach(v => buildNode(v, any_type, table, output));
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+            case OperatorType.TYPE_LOGIC_HAS_SUBSTRING:
+                if (node.parameters.length < 2)
+                    ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2' + JSON.stringify(node));
+                node.parameters.reverse().forEach(v => buildNode(v, ValueType.TYPE_STRING, table, output));
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
+                output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+                break;
+        }
+    }
+    else if (node?.calc !== undefined) {
+        checkType(ValueType.TYPE_U256, type_required, node);
+        if (node.parameters.length < 2)
+            ERROR(Errors.InvalidParam, 'node calc parameters length must >= 2' + JSON.stringify(node));
+        node.parameters.reverse().forEach(v => buildNode(v, 'number', table, output));
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.calc)); // TYPE 
+        output.push((Bcs.getInstance().ser(ValueType.TYPE_U8, node.parameters.length)));
+    }
+    else if (node?.value_type !== undefined) {
+        checkType(node?.value_type, type_required, node);
+        if (node?.value === undefined)
+            ERROR(Errors.InvalidParam, 'node value undefined - ' + JSON.stringify(node));
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.value_type)); // TYPE
+        if (node.value_type == ValueType.TYPE_STRING || node.value_type === ValueType.TYPE_VEC_U8) {
+            if (typeof (node.value) == 'string') {
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_STRING, node.value));
+            }
+            else {
+                output.push(Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, node.value));
+            }
+        }
+        else {
+            output.push(Bcs.getInstance().ser(node?.value_type, node.value));
+        }
+    }
+    else if (node?.context !== undefined) {
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.context));
+        switch (node.context) {
+            case ContextType.TYPE_CLOCK:
+                checkType(ValueType.TYPE_U64, type_required, node);
+                break;
+            case ContextType.TYPE_GUARD:
+            case ContextType.TYPE_SIGNER:
+                checkType(ValueType.TYPE_ADDRESS, type_required, node);
+                break;
+        }
+    }
+    else if (node?.identifier !== undefined) {
+        if (!IsValidGuardIdentifier(node.identifier))
+            ERROR(Errors.IsValidGuardIdentifier, 'node - ' + JSON.stringify(node));
+        const i = table.find(v => v.identifier === node.identifier);
+        if (!i)
+            ERROR(Errors.InvalidParam, 'identifier not found. node - ' + JSON.stringify(node));
+        checkType(i.value_type, type_required, node);
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
+        output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.identifier));
+    }
+    else {
+        ERROR(Errors.InvalidParam, 'node - ' + JSON.stringify(node));
+    }
+};
+const checkType = (type, type_required, node) => {
+    if (type_required === 'variable') {
+        type_required = type;
+    }
+    else if (type_required === 'number') {
+        if (type === ValueType.TYPE_U128 || type === ValueType.TYPE_U256 || type === ValueType.TYPE_U8 ||
+            type === ValueType.TYPE_U64 || type === ContextType.TYPE_CLOCK) {
+            return;
+        }
+    }
+    else if (type_required === ValueType.TYPE_ADDRESS) {
+        if (type === ContextType.TYPE_SIGNER || type === ContextType.TYPE_GUARD) {
+            return;
+        }
+    } /*else if (type_required === ValueType.TYPE_STRING) {
+        if (type === ValueType.TYPE_VEC_U8) {
+            return
+        }
+    } else if (type_required === ValueType.TYPE_VEC_U8) {
+        if (type === ValueType.TYPE_STRING) {
+            return
+        }
+    } */
+    if (type !== type_required) {
+        var str = '';
+        if (node)
+            str = ' - ' + JSON.stringify(node);
+        ERROR(Errors.InvalidParam, 'checkType: ' + type + ' require type: ' + type_required + str);
+    }
+};

package/dist/src/call/machine.d.ts

@@ -0,0 +1,109 @@
+import { PassportObject, TransactionBlock, Machine_Forward, Machine_Node, Deliverable, ParentProgress, ProgressNext } from 'wowok';
+import { CallBase, CallResult, Namedbject } from "./base";
+export interface CallMachine_Data {
+    object?: {
+        address: string;
+    } | {
+        namedNew: Namedbject;
+    };
+    permission?: {
+        address: string;
+    } | {
+        namedNew: Namedbject;
+        description?: string;
+    };
+    description?: string;
+    endpoint?: string;
+    consensus_repository?: {
+        op: 'set' | 'add' | 'remove';
+        repositories: string[];
+    } | {
+        op: 'removeall';
+    };
+    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;
+        }[];
+    };
+    bPublished?: boolean;
+    progress_new?: {
+        task_address?: string;
+        namedNew?: Namedbject;
+    };
+    progress_context_repository?: {
+        progress?: string;
+        repository: string;
+    };
+    progress_namedOperator?: {
+        progress?: string;
+        data: {
+            name: string;
+            operator: string[];
+        }[];
+    };
+    progress_parent?: {
+        progress?: string;
+        parent?: ParentProgress;
+    };
+    progress_task?: {
+        progress?: string;
+        task: string;
+    };
+    progress_hold?: {
+        progress?: string;
+        data: ProgressNext;
+        bHold: boolean;
+        adminUnhold?: boolean;
+    };
+    progress_next?: {
+        progress: string;
+        data: ProgressNext;
+        deliverable: Deliverable;
+        guard?: string | 'fetch';
+    };
+    bPaused?: boolean;
+    clone_new?: {
+        namedNew: Namedbject;
+    };
+}
+export declare class CallMachine extends CallBase {
+    data: CallMachine_Data;
+    constructor(data: CallMachine_Data);
+    call(account?: string): Promise<CallResult>;
+    protected operate(txb: TransactionBlock, passport?: PassportObject, account?: string): Promise<void>;
+}
+//# sourceMappingURL=machine.d.ts.map

package/dist/src/call/machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/call/machine.ts"],"names":[],"mappings":"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"}

package/dist/src/call/machine.js

@@ -0,0 +1,210 @@
+import { IsValidAddress, Errors, ERROR, Permission, PermissionIndex, Machine, Progress, } from 'wowok';
+import { CallBase } from "./base";
+import { Account } from '../account';
+export class CallMachine extends CallBase {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async call(account) {
+        var checkOwner = false;
+        const guards = [];
+        const perms = [];
+        const permission_address = this.data?.permission?.address;
+        const object_address = this.data?.object?.address;
+        if (permission_address && IsValidAddress(permission_address)) {
+            if (!this.data?.object) {
+                perms.push(PermissionIndex.machine);
+            }
+            if (this.data?.description !== undefined && object_address) {
+                perms.push(PermissionIndex.machine_description);
+            }
+            if (this.data?.endpoint !== undefined && object_address) {
+                perms.push(PermissionIndex.machine_endpoint);
+            }
+            if (this.data?.consensus_repository !== undefined) {
+                perms.push(PermissionIndex.machine_repository);
+            }
+            if (this.data?.nodes !== undefined) {
+                perms.push(PermissionIndex.machine_node);
+            }
+            if (this.data?.bPublished) { // publish is an irreversible one-time operation 
+                perms.push(PermissionIndex.machine_publish);
+            }
+            if (this.data?.progress_new !== undefined) {
+                perms.push(PermissionIndex.progress);
+            }
+            if (this.data?.progress_context_repository !== undefined) {
+                perms.push(PermissionIndex.progress_context_repository);
+            }
+            if (this.data?.progress_namedOperator !== undefined) {
+                perms.push(PermissionIndex.progress_namedOperator);
+            }
+            if (this.data?.progress_parent !== undefined) {
+                perms.push(PermissionIndex.progress_parent);
+            }
+            if (this.data?.progress_task !== undefined) {
+                perms.push(PermissionIndex.progress_bind_task);
+            }
+            if (this.data?.progress_hold !== undefined) {
+                if (this.data.progress_hold.adminUnhold) {
+                    perms.push(PermissionIndex.progress_unhold);
+                }
+            }
+            if (this.data?.bPaused !== undefined) {
+                perms.push(PermissionIndex.machine_pause);
+            }
+            if (this.data?.progress_next?.guard !== undefined) {
+                if (IsValidAddress(this.data?.progress_next?.guard)) {
+                    guards.push(this.data?.progress_next?.guard);
+                }
+                else if (this.data?.object && IsValidAddress(object_address)) { // fetch guard
+                    const guard = await Progress.QueryForwardGuard(this.data?.progress_next.progress, object_address, await Account.Instance().get_address() ?? '0xe386bb9e01b3528b75f3751ad8a1e418b207ad979fea364087deef5250a73d3f', this.data.progress_next.data.next_node_name, this.data.progress_next.data.forward);
+                    if (guard) {
+                        guards.push(guard);
+                    }
+                }
+            }
+            return await this.check_permission_and_call(permission_address, perms, guards, checkOwner, undefined, account);
+        }
+        return await this.exec(account);
+    }
+    async operate(txb, passport, account) {
+        let obj;
+        let permission;
+        const permission_address = this.data?.permission?.address;
+        const object_address = this.data?.object?.address;
+        if (!object_address) {
+            if (!permission_address || !IsValidAddress(permission_address)) {
+                const d = this.data?.permission?.description ?? '';
+                permission = Permission.New(txb, d);
+            }
+            obj = Machine.New(txb, permission ? permission.get_object() : permission_address, this.data?.description ?? '', this.data?.endpoint ?? '', permission ? undefined : passport);
+        }
+        else {
+            if (IsValidAddress(object_address) && permission_address && IsValidAddress(permission_address)) {
+                obj = Machine.From(txb, permission_address, object_address);
+            }
+            else {
+                ERROR(Errors.InvalidParam, 'object or permission address invalid.');
+            }
+        }
+        if (obj) {
+            const perm = permission ? permission.get_object() : permission_address;
+            const pst = permission ? undefined : passport;
+            if (this.data?.description !== undefined && object_address) {
+                obj?.set_description(this.data.description, pst);
+            }
+            if (this.data?.endpoint !== undefined && object_address) {
+                obj?.set_endpoint(this.data.endpoint, pst);
+            }
+            if (this.data?.consensus_repository !== undefined) {
+                switch (this.data.consensus_repository.op) {
+                    case 'add':
+                        this.data.consensus_repository.repositories.forEach(v => obj?.add_repository(v, pst));
+                        break;
+                    case 'remove':
+                        obj?.remove_repository(this.data.consensus_repository.repositories, false, pst);
+                        break;
+                    case 'removeall':
+                        obj?.remove_repository([], true, pst);
+                        break;
+                    case 'set':
+                        obj?.remove_repository([], true, pst);
+                        this.data.consensus_repository.repositories.forEach(v => obj?.add_repository(v, pst));
+                        break;
+                }
+            }
+            if (this.data?.nodes !== undefined) {
+                switch (this.data?.nodes?.op) {
+                    case 'add':
+                        obj?.add_node(this.data.nodes.data, pst);
+                        break;
+                    case 'remove':
+                        obj?.remove_node(this.data.nodes.names, this.data.nodes?.bTransferMyself, pst);
+                        break;
+                    case 'rename node':
+                        this.data.nodes.data.forEach(v => obj?.rename_node(v.old, v.new, pst));
+                        break;
+                    case 'add from myself':
+                        obj?.add_node2(this.data.nodes.addresses, pst);
+                        break;
+                    case 'add forward':
+                        this.data.nodes.data.forEach(v => obj?.add_forward(v.prior_node_name, v.node_name, v.forward, v.threshold, v.old_need_remove, pst));
+                        break;
+                    case 'remove forward':
+                        this.data.nodes.data.forEach(v => obj?.remove_forward(v.prior_node_name, v.node_name, v.forward_name, pst));
+                        break;
+                }
+            }
+            if (this.data?.bPublished) {
+                obj?.publish(passport);
+            }
+            var new_progress;
+            if (this.data?.progress_new !== undefined) {
+                new_progress = Progress?.New(txb, obj?.get_object(), perm, this.data?.progress_new.task_address, pst);
+            }
+            if (this.data?.progress_context_repository !== undefined) {
+                const p = this.data?.progress_context_repository.progress ?? new_progress?.get_object();
+                if (!p)
+                    ERROR(Errors.Fail, 'progress invalid: progress_context_repository');
+                Progress.From(txb, obj?.get_object(), perm, p).set_context_repository(this.data?.progress_context_repository.repository, pst);
+            }
+            if (this.data?.progress_namedOperator !== undefined) {
+                const p = this.data?.progress_namedOperator.progress ?? new_progress?.get_object();
+                if (!p)
+                    ERROR(Errors.Fail, 'progress invalid: progress_namedOperator');
+                let pp = Progress.From(txb, obj?.get_object(), perm, p);
+                this.data.progress_namedOperator.data.forEach(v => pp.set_namedOperator(v.name, v.operator, pst));
+            }
+            if (this.data?.progress_parent !== undefined) {
+                const p = this.data?.progress_parent.progress ?? new_progress?.get_object();
+                if (!p)
+                    ERROR(Errors.Fail, 'progress invalid: progress_parent');
+                if (this.data.progress_parent.parent) {
+                    Progress.From(txb, obj?.get_object(), perm, p).parent(this.data.progress_parent.parent);
+                }
+                else {
+                    Progress.From(txb, obj?.get_object(), perm, p).parent_none();
+                }
+            }
+            if (this.data?.progress_task !== undefined) {
+                const p = this.data?.progress_task.progress ?? new_progress?.get_object();
+                if (!p)
+                    ERROR(Errors.Fail, 'progress invalid: progress_task');
+                Progress.From(txb, obj?.get_object(), perm, p).bind_task(this.data.progress_task.task, pst);
+            }
+            if (this.data?.progress_hold !== undefined) {
+                const p = this.data?.progress_hold.progress ?? new_progress?.get_object();
+                if (!p)
+                    ERROR(Errors.Fail, 'progress invalid: progress_hold');
+                if (this.data?.progress_hold.adminUnhold) {
+                    Progress.From(txb, obj?.get_object(), perm, p).unhold(this.data.progress_hold.data, pst);
+                }
+                else {
+                    Progress.From(txb, obj?.get_object(), perm, p).hold(this.data.progress_hold.data, this.data.progress_hold.bHold);
+                }
+            }
+            const addr = new_progress?.launch();
+            if (addr) {
+                await this.new_with_mark(txb, addr, this.data?.progress_new?.namedNew, account);
+            }
+            if (this.data?.progress_next !== undefined) {
+                Progress.From(txb, obj?.get_object(), perm, this.data?.progress_next.progress).next(this.data.progress_next.data, this.data.progress_next.deliverable, pst);
+            }
+            if (this.data?.bPaused !== undefined) {
+                obj?.pause(this.data.bPaused, pst);
+            }
+            if (this.data?.clone_new !== undefined && obj) {
+                await this.new_with_mark(txb, obj?.clone(true, pst), this.data?.clone_new?.namedNew, account);
+            }
+            if (permission) {
+                await this.new_with_mark(txb, permission.launch(), this.data?.permission?.namedNew, account);
+            }
+            if (!object_address) {
+                await this.new_with_mark(txb, obj.launch(), this.data?.object?.namedNew, account);
+            }
+        }
+    }
+}

package/dist/src/call/object_permission.d.ts

@@ -0,0 +1,13 @@
+import { CallBase, CallResult } from "./base";
+import { TransactionBlock, PassportObject } from 'wowok';
+export interface CallObjectPermission_Data {
+    objects: string[];
+    new_permission: string;
+}
+export declare class CallObjectPermission extends CallBase {
+    data: CallObjectPermission_Data;
+    constructor(data: CallObjectPermission_Data);
+    call(account?: string): Promise<CallResult>;
+    protected operate(txb: TransactionBlock, passport?: PassportObject): Promise<void>;
+}
+//# sourceMappingURL=object_permission.d.ts.map

package/dist/src/call/object_permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object_permission.d.ts","sourceRoot":"","sources":["../../../src/call/object_permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAA8F,MAAM,OAAO,CAAC;AAGrJ,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,oBAAqB,SAAQ,QAAQ;IAC9C,IAAI,EAAE,yBAAyB,CAAC;gBACpB,IAAI,EAAC,yBAAyB;IAKpC,IAAI,CAAC,OAAO,CAAC,EAAC,MAAM,GAAI,OAAO,CAAC,UAAU,CAAC;cASjC,OAAO,CAAE,GAAG,EAAC,gBAAgB,EAAE,QAAQ,CAAC,EAAC,cAAc;CA+B1E"}

package/dist/src/call/object_permission.js

@@ -0,0 +1,49 @@
+import { CallBase } from "./base";
+import { IsValidAddress, Errors, ERROR, Demand, Machine, Service, Treasury, Arbitration, Repository } from 'wowok';
+import { query_objects } from "../objects";
+export class CallObjectPermission extends CallBase {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async call(account) {
+        if (!IsValidAddress(this.data.new_permission)) {
+            ERROR(Errors.InvalidParam, 'CallObjectPermission_Data.new_permission' + this.data.new_permission);
+        }
+        if (this.data?.objects.length > 0) {
+            return await this.exec(account);
+        }
+    }
+    async operate(txb, passport) {
+        const r = await query_objects({ objects: this.data.objects, showContent: true });
+        r.objects?.forEach(v => {
+            switch (v.type) {
+                case 'Demand':
+                    const demand = v;
+                    Demand.From(txb, Demand.parseObjectType(demand.type_raw), demand.permission, demand.object).change_permission(this.data.new_permission);
+                    break;
+                case 'Machine':
+                    const machine = v;
+                    Machine.From(txb, machine.permission, machine.object).change_permission(this.data.new_permission);
+                    break;
+                case 'Service':
+                    const service = v;
+                    Service.From(txb, Service.parseObjectType(service.type_raw), service.permission, service.object).change_permission(this.data.new_permission);
+                    break;
+                case 'Treasury':
+                    const treasury = v;
+                    Treasury.From(txb, Treasury.parseObjectType(treasury.type_raw), treasury.permission, treasury.object).change_permission(this.data.new_permission);
+                    break;
+                case 'Arbitration':
+                    const arbitraion = v;
+                    Arbitration.From(txb, Arbitration.parseObjectType(arbitraion.type_raw), arbitraion.permission, arbitraion.object).change_permission(this.data.new_permission);
+                    break;
+                case 'Repository':
+                    const repository = v;
+                    Repository.From(txb, repository.permission, repository.object).change_permission(this.data.new_permission);
+                    break;
+            }
+        });
+    }
+}