wowok_agent 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok_agent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/account.ts

@@ -15,8 +15,8 @@ export interface AccountData_Show {
     address: string;
 }
 
-const Account_FileName = 'wowok.dat';
-const Account_Key = 'wowok-data-v1';
+const Account_FileName = 'wowok.acc.dat';
+const Account_Key = 'wowok-acc-v1';
 
 export class Account {
     constructor(storage: 'File' | 'Explorer' = 'File') {
@@ -32,64 +32,61 @@ export class Account {
 
     private storage: 'File' | 'Explorer' = 'File';
 
-    private _add(buffer:string | null | undefined, name:string, bDefault?: boolean) : AccountData[] {
+    private _add(buffer:string | null | undefined, name:string, bDefault?: boolean) : AccountData[] | undefined {
         var data : AccountData[] | undefined;
         var key = '0x'+toHEX(decodeSuiPrivateKey(Ed25519Keypair.generate().getSecretKey()).secretKey);
 
         try {
             if (buffer) {
-                data = JSON.parse(buffer) as AccountData[];            
-            }
-        } catch(e) { console.log(e) }
-
-        if (data) {
-            const f = data.find(v => v.name === name);
-            if (f) {
-                f.default = bDefault;
-            } else {
-                if (bDefault) {
-                    data.forEach(v => v.default = false)
+                data = JSON.parse(buffer) as AccountData[];       
+                if (data) {
+                    const f = data.find(v => v.name === name);
+                    if (f) {
+                        f.default = bDefault;
+                    } else {
+                        if (bDefault) {
+                            data.forEach(v => v.default = false)
+                        }
+                        data.push({name:name, key:key, default:bDefault})
+                    }
+                } else {
+                    data = [{name:name, key:key, default:bDefault}];
                 }
-                data.push({name:name, key:key, default:bDefault})
+                return data     
             }
-        } else {
-            data = [{name:name, key:key, default:bDefault}];
-        }
-        return data
+        } catch(e) { console.log(e) }
     }
 
     private _default(buffer:string | null | undefined) : AccountData | undefined {
         var data : AccountData[] | undefined;
         try {
             if (buffer) {
-                data = JSON.parse(buffer) as AccountData[];            
+                data = JSON.parse(buffer) as AccountData[];    
+                if (data) {
+                    const f = data.find(v => v.default);
+                    if (f) {
+                        return f
+                    } 
+                }         
             }
         } catch(e) { console.log(e) }
-
-        if (data) {
-            const f = data.find(v => v.default);
-            if (f) {
-                return f
-            } 
-        } 
     }
     private _get(buffer:string | null | undefined, name?:string, bNotFoundReturnDefault?:boolean) : AccountData | undefined {
         var data : AccountData[] | undefined;
         try {
             if (buffer) {
-                data = JSON.parse(buffer) as AccountData[];            
+                data = JSON.parse(buffer) as AccountData[];
+                if (data) {
+                    const f = data.find(v => v.name === name);
+                    if (f) {
+                        return f
+                    } 
+                    if (bNotFoundReturnDefault) {
+                        return data.find(v => v.default)
+                    }
+                }             
             }
         } catch(e) { console.log(e) }
-
-        if (data) {
-            const f = data.find(v => v.name === name);
-            if (f) {
-                return f
-            } 
-            if (bNotFoundReturnDefault) {
-                return data.find(v => v.default)
-            }
-        } 
     }
     private _rename(buffer:string | null | undefined, oldName:string, newName:string, bSwapIfExisted:boolean=true) : AccountData[] | undefined {
         var data : AccountData[] | undefined;
@@ -97,25 +94,24 @@ export class Account {
             if (buffer) {
                 data = JSON.parse(buffer) as AccountData[];            
             }
-        } catch(e) { console.log(e) }
-
-        if (data) {
-            const f1 = data.find(v => v.name === oldName);
-            if (!f1) return undefined;
 
-            const f2 = data.find(v => v.name === newName);
-            if (f2) {
-                if (bSwapIfExisted) {
+            if (data) {
+                const f1 = data.find(v => v.name === oldName);
+                if (!f1) return undefined;
+    
+                const f2 = data.find(v => v.name === newName);
+                if (f2) {
+                    if (bSwapIfExisted) {
+                        f1.name = newName;
+                        f2.name = oldName;
+                        return data
+                    } 
+                } else {
                     f1.name = newName;
-                    f2.name = oldName;
-                    return data
-                } 
-            } else {
-                f1.name = newName;
-                return data;
-            }
-        } 
-        return undefined
+                    return data;
+                }
+            } 
+        } catch(e) { console.log(e) }
     }
     
     set_storage(storage: 'File' | 'Explorer' = 'File') {

package/src/call/arbitration.ts

@@ -1,28 +1,26 @@
-import { TransactionBlock, IsValidArgType, Resource, ResourceObject, } from 'wowok';
-import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Treasury, 
-    Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, WitnessFill
+import { TransactionBlock, IsValidArgType, PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, 
+    PermissionIndexType, Treasury, Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, 
 } from 'wowok';
 import { query_objects, ObjectArbitration, } from '../objects';
-import { CallBase, CallResult, AddressMark, Namedbject} from "./base";
+import { CallBase, CallResult, Namedbject} from "./base";
 
 export interface CallArbitration_Data {
+    type_parameter: string;
     object?: {address:string} | {namedNew: Namedbject}; // undefined or {named_new...} for creating a new object
     permission?: {address:string} | {namedNew: Namedbject, description?:string}; 
-    mark?:AddressMark;
-    type_parameter: string;
-    permission_new?: string;
     description?: string;
-    bPaused?: boolean;
     endpoint?: string;
     fee?: string;
     fee_treasury?: {address:string} | {namedNew: Namedbject, description?:string}; 
-    usage_guard?: string;
-    voting_guard?: {op:'add' | 'set'; data:VotingGuard[]} | {op:'remove', guards:string[]} | {op:'removeall'};
     arb_new?: {data: Dispute; guard?:string | 'fetch'; namedNew?: Namedbject}; // dispute an order, and a new Arb launched.
     arb_withdraw_fee?: {arb:string; data:WithdrawFee};
     arb_vote?: Vote;
     arb_arbitration?: Feedback;
+    usage_guard?: string;
+    voting_guard?: {op:'add' | 'set'; data:VotingGuard[]} | {op:'remove', guards:string[]} | {op:'removeall'};
+    bPaused?: boolean;
 }
+
 export class CallArbitration extends CallBase {
     data: CallArbitration_Data;
     constructor (data: CallArbitration_Data) {
@@ -45,9 +43,6 @@ export class CallArbitration extends CallBase {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.arbitration)
             }
-            if (this.data?.permission_new !== undefined) {
-                checkOwner = true;
-            }
             if (this.data?.description !== undefined && object_address) {
                 perms.push(PermissionIndex.arbitration_description)
             }
@@ -121,10 +116,9 @@ export class CallArbitration extends CallBase {
                 withdraw_treasury = Treasury.New(txb, this.data?.type_parameter!, permission ? permission.get_object() : permission_address, 
                     d, permission?undefined:passport);
             }
-
             obj = Arbitration.New(txb, this.data.type_parameter!, permission ? permission.get_object() : permission_address, this.data?.description??'', 
                 BigInt(this.data?.fee ?? 0), withdraw_treasury? withdraw_treasury.get_object() : treasury_address, permission?undefined:passport);
-        } else if (object_address) {
+        } else {
             if (IsValidAddress(object_address) && this.data.type_parameter && permission_address) {
                 obj = Arbitration.From(txb, this.data.type_parameter, permission_address, object_address)
             } else {
@@ -136,9 +130,6 @@ export class CallArbitration extends CallBase {
             if (this.data?.description !== undefined && object_address) {
                 obj?.set_description(this.data.description, passport);
             }
-            if (this.data?.bPaused !== undefined) {
-                obj?.pause(this.data.bPaused, passport);
-            }
             if (this.data?.endpoint !== undefined) {
                 obj?.set_endpoint(this.data.endpoint, passport)
             }
@@ -148,8 +139,17 @@ export class CallArbitration extends CallBase {
             if (treasury_address !== undefined && object_address) {
                 obj?.set_withdrawTreasury(treasury_address, passport)
             }
-            if (this.data.usage_guard !== undefined) {
-                obj?.set_guard(this.data.usage_guard, passport)
+            if (this.data?.arb_new !== undefined) {
+                await this.new_with_mark(txb, obj?.dispute(this.data.arb_new.data, passport), (this.data?.arb_new as any)?.namedNew, account);
+            }
+            if (this.data?.arb_arbitration !== undefined) {
+                obj?.arbitration(this.data.arb_arbitration, passport)
+            }
+            if (this.data?.arb_vote !== undefined) {
+                obj?.vote(this.data.arb_vote, passport)
+            }
+            if (this.data?.arb_withdraw_fee !== undefined) {
+                obj?.withdraw_fee(this.data.arb_withdraw_fee.arb, this.data.arb_withdraw_fee.data, passport)
             }
             if (this.data?.voting_guard !== undefined) {
                 switch (this.data.voting_guard.op) {
@@ -168,23 +168,12 @@ export class CallArbitration extends CallBase {
                         break;
                 }
             }
-            
-            if (this.data?.arb_new !== undefined) {
-                await this.new_with_mark(txb, obj?.dispute(this.data.arb_new.data, passport), (this.data?.arb_new as any)?.namedNew, account);
-            }
-            if (this.data?.arb_arbitration !== undefined) {
-                obj?.arbitration(this.data.arb_arbitration, passport)
-            }
-            if (this.data?.arb_vote !== undefined) {
-                obj?.vote(this.data.arb_vote, passport)
-            }
-            if (this.data?.arb_withdraw_fee !== undefined) {
-                obj?.withdraw_fee(this.data.arb_withdraw_fee.arb, this.data.arb_withdraw_fee.data, passport)
+            if (this.data.usage_guard !== undefined) {
+                obj?.set_guard(this.data.usage_guard, passport)
             }
-            if (this.data?.permission_new !== undefined) {
-                obj?.change_permission(this.data.permission_new);
+            if (this.data?.bPaused !== undefined) {
+                obj?.pause(this.data.bPaused, passport);
             }
-
             if (withdraw_treasury) {
                 await this.new_with_mark(txb, withdraw_treasury.launch(), (this.data?.fee_treasury as any)?.namedNew, account);
             }

package/src/call/base.ts

@@ -9,7 +9,7 @@ import { Account } from '../account';
 import { ObjectBase, queryTableItem_Personal, raw2type} from '../objects';
 
 export interface Namedbject {
-    name: string;
+    name?: string;
     tags?: string[];
 }
 
@@ -32,6 +32,7 @@ export interface CallWithWitnessParam {
 }
 export type CallResult = GuardInfo_forCall | CallResponse | undefined;
 
+
 export function ResponseData(response: CallResponse | undefined) : ResponseData[] {
     const res : ResponseData[] = [];
     response?.objectChanges?.forEach(v => {

package/src/call/demand.ts

@@ -5,18 +5,18 @@ import { query_objects, ObjectDemand } from '../objects';
 import { CallBase, CallResult, Namedbject } from "./base";
 import { Account } from '../account';
 
+/// The execution priority is determined by the order in which the object attributes are arranged
 export interface CallDemand_Data {
+    type_parameter: string;
     object?: {address:string} | {namedNew: Namedbject}; // undefined or {named_new...} for creating a new object
     permission?: {address:string} | {namedNew: Namedbject, description?: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:{address:string}|{balance:string|number}} | {op:'refund'} | {op:'reward'; service:string};
+    bounty?: {op:'add'; object:{address:string}|{balance:string|number}} | {op:'reward'; service:string} | {op:'refund'} ;
     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;
+    guard?: {address:string; service_id_in_guard?:number};
 }
+
 export class CallDemand extends CallBase {
     data: CallDemand_Data;
     constructor(data: CallDemand_Data) {
@@ -46,10 +46,10 @@ export class CallDemand extends CallBase {
             if (this.data?.guard !== undefined) {
                 perms.push(PermissionIndex.demand_guard)
             }
-            if (this.data?.reward !== undefined) {
+            if (this.data?.bounty?.op === 'reward') {
                 perms.push(PermissionIndex.demand_yes)
             }
-            if (this.data?.refund) {
+            if (this.data?.bounty?.op === 'refund') {
                 perms.push(PermissionIndex.demand_refund)
             }
             if (this.data?.present?.guard !== undefined) {
@@ -121,11 +121,11 @@ export class CallDemand extends CallBase {
                         const r = await Account.Instance().get_coin_object(txb, (this.data.bounty.object as any)?.balance, account, this.data.type_parameter);
                         if (r) obj.deposit(r)
                     }
-                } else if (this.data.bounty.op === 'refund') {
-                    obj?.refund(passport);
                 } else if (this.data.bounty.op === 'reward') {
                     obj?.yes(this.data.bounty.service, passport);
-                }
+                } else if (this.data.bounty.op === 'refund') {
+                    obj?.refund(passport);
+                } 
             }
             if (this.data?.present !== undefined) {
                 //@ demand guard and its passport, if set

package/src/call/guard.ts

@@ -5,7 +5,8 @@
 
 import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, 
     concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead, CallResponse, 
-    IsValidDesription, PassportObject} from "wowok";
+    IsValidDesription, PassportObject,
+    IsValidGuardIdentifier} from "wowok";
 import { CallBase, CallResult, Namedbject } from "./base";
 
 export interface GuardConst {
@@ -26,6 +27,7 @@ export type GuardNode = { identifier: number; } // Data from GuardConst
     | {calc: OperatorType.TYPE_NUMBER_ADD | OperatorType.TYPE_NUMBER_DEVIDE | OperatorType.TYPE_NUMBER_MOD 
         | OperatorType.TYPE_NUMBER_MULTIPLY | OperatorType.TYPE_NUMBER_SUBTRACT; parameters: GuardNode[];}
     | {value_type: ValueType; value:any; } // Data 
+    | {identifier: number} // data from GuardConst
     | {context: ContextType.TYPE_CLOCK | ContextType.TYPE_GUARD | ContextType.TYPE_SIGNER }; // Data from run-time environment
 
 export interface CallGuard_Data {
@@ -74,7 +76,6 @@ export class CallGuard extends CallBase {
         this.data?.table?.forEach((v) => {
             if (v.bWitness) {
                 const n = new Uint8Array(1); n.set([v.value_type], 0);
-                console.log(n)
                 txb.moveCall({
                     target:Protocol.Instance().guardFn("constant_add") as FnCallType,
                     arguments:[txb.object(obj), txb.pure.u8(v.identifier), txb.pure.bool(true), txb.pure.vector('u8', [].slice.call(n)), txb.pure.bool(false)]
@@ -107,13 +108,13 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
             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 - ' + node.toString());
+            ERROR(Errors.InvalidParam, 'node identifier - ' + JSON.stringify(node));
         }
     } else if (node?.query !== undefined) {
         var q: any[] | undefined;
-        if (typeof(node.query === 'string')) {
+        if (typeof(node.query) === 'string') {
             q = GUARD_QUERIES.find(v=>v[1] === node.query);
-        } else if (typeof(node.query === 'number')) {
+        } else if (typeof(node.query) === 'number') {
             q = GUARD_QUERIES.find(v=>v[2] === node.query);
         }
         if (!q) ERROR(Errors.InvalidParam, 'query invalid - ' + node?.query);
@@ -124,13 +125,13 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
                 buildNode(node.parameters[i], q![3][i], table, output); // Recursive check
             }
         } else {
-            ERROR(Errors.InvalidParam, 'node query parameters length not match - ' + node.toString())
+            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 - ' + node.toString())
+                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             
@@ -141,7 +142,7 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
                 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 - ' + node.toString());
+                ERROR(Errors.InvalidParam, 'node object from identifier - ' + JSON.stringify(node));
             }
         }
         output.push(Bcs.getInstance().ser('u16', q![2])); // cmd(u16)
@@ -149,18 +150,18 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
         checkType(ValueType.TYPE_BOOL, type_required, node); // bool
         switch (node?.logic) {
             case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
-                if (node.parameters.length !== 0) ERROR(Errors.InvalidParam, 'node logic parameters length must be 0'+ node.toString());
+                if (node.parameters.length !== 0) ERROR(Errors.InvalidParam, 'node logic parameters length must be 0'+ JSON.stringify(node));
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 break;
             case OperatorType.TYPE_LOGIC_AND:
             case OperatorType.TYPE_LOGIC_OR:
-                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ node.toString()); 
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node)); 
                 (node.parameters as GuardNode[]).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'+ node.toString());
+                if (node.parameters.length !== 1) ERROR(Errors.InvalidParam, 'node logic parameters length must be 1'+ JSON.stringify(node));
                 (node.parameters as GuardNode[]).reverse().forEach(v => buildNode(v, ValueType.TYPE_BOOL, table, output)); // reserve
                 output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
                 break;
@@ -169,20 +170,20 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
             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'+ node.toString());
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
                 (node.parameters as GuardNode[]).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'+ node.toString());
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
                 var any_type: any = 'variable';
                 (node.parameters as GuardNode[]).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'+ node.toString());
+                if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));
                 (node.parameters as GuardNode[]).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)));
@@ -190,13 +191,13 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
         }
     } 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'+ node.toString());
+        if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node calc parameters length must >= 2'+ JSON.stringify(node));
         (node.parameters as GuardNode[]).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 - ' + node.toString());
+        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) {
@@ -219,8 +220,15 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
                 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 - ' + node.toString())
+        ERROR(Errors.InvalidParam, 'node - ' + JSON.stringify(node))
     }
 }
 
@@ -250,8 +258,7 @@ const checkType = (type: ValueType | ContextType.TYPE_CLOCK | ContextType.TYPE_G
 
     if (type !== type_required) {
         var str = '';
-        if (node) str = ' - ' + node.toString();
-        console.log(node)
+        if (node) str = ' - ' + JSON.stringify(node);
         ERROR(Errors.InvalidParam, 'checkType: ' + type + ' require type: ' + type_required + str);
     }
 }

package/src/call/machine.ts

@@ -1,36 +1,34 @@
-import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, TransactionBlock,
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, TransactionBlock, TxbAddress,
     PermissionIndexType, Machine, Machine_Forward, Machine_Node,  Deliverable, ParentProgress, Progress, ProgressNext,
-    TxbAddress,
-    Resource,
-    ResourceObject,
 } from 'wowok';
 import { CallBase, CallResult, Namedbject } from "./base";
 import { Account } from '../account';
 
+/// The execution priority is determined by the order in which the object attributes are arranged
 export interface CallMachine_Data {
     object?: {address:string} | {namedNew: Namedbject}; // undefined or {named_new...} for creating a new object
     permission?: {address:string} | {namedNew: Namedbject, description?:string}; 
-    bPaused?: boolean;
-    bPublished?: boolean;
-    consensus_repository?: {op:'set' | 'add' | 'remove' ; repositories:string[]} | {op:'removeall'};
     description?: string;
     endpoint?: string;
-    clone_new?: {namedNew: Namedbject/*, description?: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}[]}
+    | {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_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'};
+    bPaused?: boolean;
+    clone_new?: {namedNew: Namedbject/*, description?:string*/};
 }
 export class CallMachine extends CallBase { //@ todo self-owned node operate
-    data: CallMachine_Data
+    data: CallMachine_Data;
     constructor(data:CallMachine_Data) {
         super();
         this.data = data;
@@ -48,24 +46,18 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
             if (this.data?.description !== undefined && object_address) {
                 perms.push(PermissionIndex.machine_description)
             }
-            if (this.data?.bPaused !== undefined) {
-                perms.push(PermissionIndex.machine_pause)
-            }
-            if (this.data?.bPublished) { // publish is an irreversible one-time operation 
-                perms.push(PermissionIndex.machine_publish)
-            }
             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?.clone_new !== undefined) {
-                perms.push(PermissionIndex.machine_clone)
-            }
             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)
             }
@@ -86,6 +78,9 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
                     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)
@@ -170,6 +165,9 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
                         break;
                     }
             }
+            if (this.data?.bPublished ) {
+                obj?.publish(passport)
+            }
             if (this.data?.progress_new !== undefined) {
                 const addr = Progress?.New(txb, obj?.get_object(), permission??this.data?.permission, this.data?.progress_new.task_address, passport).launch();
                 if (addr) {
@@ -207,16 +205,13 @@ export class CallMachine extends CallBase { //@ todo self-owned node operate
             if (this.data?.bPaused !== undefined) {
                 obj?.pause(this.data.bPaused, passport)
             }
-            if (this.data?.bPublished ) {
-                obj?.publish(passport)
-            }
-            if (this.data?.clone_new && obj) {
+            if (this.data?.clone_new !== undefined && obj) {
                 await this.new_with_mark(txb, obj?.clone(true, passport) as TxbAddress, (this.data?.clone_new as any)?.namedNew, account);
             }
             if (permission) {
                 await this.new_with_mark(txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);
             }
-            if (!this.data.object) {
+            if (!object_address) {
                 await this.new_with_mark(txb, obj.launch(), (this.data?.object as any)?.namedNew, account);
             }
         }

package/src/call/object_permission.ts

@@ -1,8 +1,5 @@
 import { CallBase, CallResult } from "./base";
-import { TransactionBlock, CallResponse, Protocol, Demand, DemandObject, Machine, Service, Treasury, Arbitration, Repository} from 'wowok';
-import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, UserDefinedIndex,
-    PermissionIndexType, WitnessFill
-} from 'wowok';
+import { TransactionBlock, PassportObject, IsValidAddress, Errors, ERROR,  Demand, Machine, Service, Treasury, Arbitration, Repository} from 'wowok';
 import { ObjectArbitration, ObjectDemand, ObjectMachine, ObjectRepository, ObjectService, ObjectTreasury, query_objects } from "../objects";
 
 export interface CallObjectPermission_Data {