wowok_agent 1.2.38 → 1.2.41

package/src/call/arbitration.ts

@@ -1,9 +1,10 @@
-import { TransactionBlock, IsValidArgType, PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, 
-    PermissionIndexType, Treasury, Arbitration, VotingGuard, WithdrawFee, ArbObject, 
+import { TransactionBlock, IsValidArgType, PassportObject, Errors, ERROR, Permission, PermissionIndex, 
+    PermissionIndexType, Treasury, Arbitration, VotingGuard, WithdrawFee, ArbObject,
 } from 'wowok';
-import { query_objects, ObjectArbitration, } from '../query/objects.js';
+import { ObjectArbitration, } from '../query/objects.js';
 import { CallBase, CallResult, Namedbject} from "./base.js";
 import { Account } from '../local/account.js';
+import { LocalMark } from '../local/local.js';
 export interface DisputeData {
     order: string,
     order_token_type: string,
@@ -21,7 +22,7 @@ export interface CallArbitration_Data {
     endpoint?: string;
     fee?: string | number;
     fee_treasury?: {address:string} | {namedNew?: Namedbject, description?:string}; 
-    arb_new?: {data: DisputeData; guard?:string | 'fetch'; namedNew?: Namedbject}; // dispute an order, and a new Arb launched.
+    arb_new?: {data: DisputeData; guard?:string; namedNew?: Namedbject}; // dispute an order, and a new Arb launched.
     arb_withdraw_fee?: {arb?:string; data:WithdrawFee};
     arb_vote?: {arb?: string; voting_guard?: string; agrees: number[]};
     arb_arbitration?: {arb?:string; feedback:string; indemnity?:string|number};
@@ -32,23 +33,36 @@ export interface CallArbitration_Data {
 
 export class CallArbitration extends CallBase {
     data: CallArbitration_Data;
+
     constructor (data: CallArbitration_Data) {
         super();
         this.data  = data;
     }
 
     async call(account?:string) : Promise<CallResult> {
-        if (!this.data?.type_parameter || !IsValidArgType(this.data.type_parameter)) {
-            ERROR(Errors.IsValidArgType, 'arbitration.type_parameter')
-        }
-
         var checkOwner = false; const guards : string[] = [];
-        const perms : PermissionIndexType[] = [];  var obj: ObjectArbitration | undefined ;
-        const permission_address = (this.data?.permission as any)?.address;
-        const object_address = (this.data?.object as any)?.address;
-        const treasury_address = (this.data?.fee_treasury as any)?.address;
+        const perms : PermissionIndexType[] = []; 
+        var [permission_address, object_address, treasury_address] = 
+            await LocalMark.Instance().get_many_address(
+                [(this.data?.permission as any)?.address, 
+                (this.data?.object as any)?.address, 
+                (this.data?.fee_treasury as any)?.address]);
+
+        if (object_address) {
+            if (!this.data.type_parameter || !permission_address) {
+                await this.update_content(object_address, 'Arbitration');
+                if (this.content) {
+                    permission_address = (this.content as ObjectArbitration).permission;     
+                    this.data.type_parameter =  this.content.type_raw!;             
+                }
+            } 
+        } else {
+            if (!this.data?.type_parameter || !IsValidArgType(this.data.type_parameter)) {
+                ERROR(Errors.IsValidArgType, 'CallArbitration_Data.data.type_parameter')
+            }
+        }
 
-        if (permission_address && IsValidAddress(permission_address)) {
+        if (permission_address) {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.arbitration)
             }
@@ -77,32 +91,33 @@ export class CallArbitration extends CallBase {
                 perms.push(PermissionIndex.arbitration_arbitration)
             }
             if (this.data?.arb_new?.guard !== undefined) {
-                if (IsValidAddress(this.data.arb_new.guard)) {
-                    guards.push(this.data.arb_new.guard)
+                if (this.data?.arb_new?.guard) {
+                    const guard = await LocalMark.Instance().get_address(this.data?.arb_new?.guard);
+                    if (guard) {
+                        guards.push(guard)
+                    } 
                 } else {
                     if (!object_address) { // new
-                        if (this.data?.guard && IsValidAddress(this.data?.guard)) {
-                            guards.push(this.data.guard)
+                        const guard = await LocalMark.Instance().get_address(this.data.guard);
+                        if (guard) {
+                            guards.push(guard);
                         }
                     } else {
-                        if (!obj) {
-                            const r = await query_objects({objects:[object_address]});
-                            if (r?.objects && r.objects[0].type === 'Arbitration') {
-                                obj = r.objects[0] as ObjectArbitration;
-                            }                                
-                        }
+                        await this.update_content(object_address, 'Arbitration');
  
-                        if (obj?.usage_guard) {
-                            guards.push(obj.usage_guard)
+                        if ((this.content as ObjectArbitration)?.usage_guard) {
+                            guards.push((this.content as ObjectArbitration).usage_guard!)
                         }                   
                     }
                 }
             }
             if (this.data?.arb_vote !== undefined) {
-                perms.push(PermissionIndex.treasury_receive)
-            }
-            if (typeof(this.data?.arb_vote?.voting_guard) === 'string' && IsValidAddress(this.data?.arb_vote?.voting_guard)) {
-                guards.push(this.data?.arb_vote?.voting_guard)
+                perms.push(PermissionIndex.arbitration_vote);
+
+                const voting_guard = await LocalMark.Instance().get_address(this.data?.arb_vote?.voting_guard);
+                if (voting_guard) {
+                    guards.push(voting_guard)
+                } 
             }
 
             return await this.check_permission_and_call(permission_address, perms, guards, checkOwner, undefined, account)
@@ -111,16 +126,19 @@ export class CallArbitration extends CallBase {
     }
     protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Arbitration | undefined ; let permission: any; let withdraw_treasury:any;
-        const permission_address = (this.data?.permission as any)?.address;
-        const object_address = (this.data?.object as any)?.address;
-        const treasury_address = (this.data?.fee_treasury as any)?.address;
+        var [permission_address, object_address] = this?.content ? 
+        [(this.content as ObjectArbitration).permission, this.content.object] : 
+            await LocalMark.Instance().get_many_address(
+                [(this.data?.permission as any)?.address, 
+                (this.data?.object as any)?.address]);
+        const treasury_address = await LocalMark.Instance().get_address((this.data?.fee_treasury as any)?.address);
 
         if (!object_address) {
-            if (!permission_address || !IsValidAddress(permission_address)) {
+            if (!permission_address) {
                 const d = (this.data?.permission as any)?.description ?? '';
                 permission = Permission.New(txb, d);
             }
-            if (!treasury_address || !IsValidAddress(treasury_address)) {
+            if (!treasury_address) {
                 const d = (this.data?.fee_treasury as any)?.description ?? '';
                 withdraw_treasury = Treasury.New(txb, this.data?.type_parameter!, permission ? permission.get_object() : permission_address, 
                     d, permission?undefined:passport);
@@ -128,10 +146,10 @@ export class CallArbitration extends CallBase {
             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 (IsValidAddress(object_address) && this.data.type_parameter && permission_address) {
+            if (this.data.type_parameter && permission_address) {
                 obj = Arbitration.From(txb, this.data.type_parameter, permission_address, object_address)
             } else {
-                ERROR(Errors.InvalidParam, 'object or permission address invalid.')
+                ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.type_parameter or permission')
             }
         }
 
@@ -151,30 +169,33 @@ export class CallArbitration extends CallBase {
             }
             var arb_new : ArbObject | undefined;
             if (this.data?.arb_new !== undefined) {
-                const b = BigInt(this.data.arb_new.data.fee); 
                 const d = this.data?.arb_new.data; 
-                arb_new = obj?.arb({order:d.order, order_token_type:d.order_token_type, description:d.description, votable_proposition:d.votable_proposition, 
-                    fee: b>BigInt(0) ? await Account.Instance().get_coin_object(txb, b, account, this.data.type_parameter) : undefined
-                }, pst);
+                const order = await LocalMark.Instance().get_address(d.order);
+                if (order) {
+                    const b = BigInt(d.fee); 
+                    arb_new = obj?.arb({order:d.order, order_token_type:d.order_token_type, description:d.description, votable_proposition:d.votable_proposition, 
+                        fee: b>BigInt(0) ? await Account.Instance().get_coin_object(txb, b, account, this.data.type_parameter) : undefined
+                    }, pst);                    
+                }
             }
 
             if (this.data?.arb_arbitration !== undefined) {
-                const a = this.data.arb_arbitration.arb ?? arb_new;
-                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_arbitration');
+                const a = await LocalMark.Instance().get_address(this.data.arb_arbitration.arb) ?? arb_new;
+                if (!a) ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.arb_arbitration.arb');
 
                 obj?.arbitration({arb:a!, feedback:this.data.arb_arbitration.feedback, indemnity:this.data.arb_arbitration.indemnity}, pst)
             }
 
             if (this.data?.arb_vote !== undefined) {
-                const a = this.data.arb_vote.arb ?? arb_new;
-                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_vote');
+                const a = await LocalMark.Instance().get_address(this.data.arb_vote.arb) ?? arb_new;
+                if (!a) ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.arb_vote.arb');
 
                 obj?.vote({arb:a!, voting_guard:this.data.arb_vote.voting_guard, agrees:this.data.arb_vote.agrees}, pst)
             }
 
             if (this.data?.arb_withdraw_fee !== undefined) {
-                const a = this.data.arb_withdraw_fee.arb ?? arb_new;
-                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_withdraw_fee');
+                const a = await LocalMark.Instance().get_address(this.data.arb_withdraw_fee.arb) ?? arb_new;
+                if (!a) ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.arb_withdraw_fee.arb');
 
                 obj?.withdraw_fee(a!, this.data.arb_withdraw_fee.data, pst)
             }
@@ -186,23 +207,35 @@ export class CallArbitration extends CallBase {
             if (this.data?.voting_guard !== undefined) {
                 switch (this.data.voting_guard.op) {
                     case 'add':
-                        obj?.add_voting_guard(this.data.voting_guard.data, pst)
+                    case 'set':
+                        for (let i = 0; i < this.data.voting_guard.data.length; ++ i) {
+                            const v = this.data.voting_guard.data[i];
+                            if (typeof(v.guard) === 'string') {
+                                const g = await LocalMark.Instance().get_address(v.guard);
+                                if (!g) {
+                                    ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.voting_guard')
+                                } 
+                                v.guard = g;
+                            } 
+                        }
+                        if (this.data.voting_guard.op === 'set') {
+                            obj?.remove_voting_guard([], true, pst)
+                        }
+                        obj?.add_voting_guard(this.data.voting_guard.data, pst);
                         break;
                     case 'remove':
-                        obj?.remove_voting_guard(this.data.voting_guard.guards, false, pst)
-                        break;
-                    case 'set':
-                        obj?.remove_voting_guard([], true, pst)
-                        obj?.add_voting_guard(this.data.voting_guard.data, pst)
+                        obj?.remove_voting_guard(await LocalMark.Instance().get_many_address2(this.data.voting_guard.guards), false, pst)
                         break;
                     case 'removeall':
                         obj?.remove_voting_guard([], true, pst)
                         break;
                 }
             }
-            if (this.data.guard !== undefined) {
-                obj?.set_guard(this.data.guard, pst)
+            const guard = await LocalMark.Instance().get_address(this.data.guard);
+            if (guard) {
+                obj?.set_guard(guard, pst)
             }
+
             if (this.data?.bPaused !== undefined) {
                 obj?.pause(this.data.bPaused, pst);
             }

package/src/call/base.ts

@@ -5,7 +5,7 @@ import { Entity, Resource, TxbAddress, array_unique, TagName, ResourceObject, Pa
 } from 'wowok';
 import { query_permission } from '../query/permission.js';
 import { Account } from '../local/account.js';
-import { ObjectBase, ObjectBaseType, query_personal, raw2type} from '../query/objects.js';
+import { ObjectArbitration, ObjectBase, ObjectBaseType, query_objects, query_personal, raw2type} from '../query/objects.js';
 import { LocalMark } from '../local/local.js';
 
 export interface Namedbject {
@@ -50,6 +50,7 @@ export class CallBase {
     // operation implementation for a call
     private resouceObject:ResourceObject | undefined;
     private traceMarkNew = new Map<ObjectBaseType, Namedbject>();
+    content: ObjectBase | undefined = undefined;
 
     protected async operate(txb:TransactionBlock, passport?:PassportObject, account?:string) {};
     constructor () {}
@@ -82,10 +83,10 @@ export class CallBase {
         var guards : string[] = [];
 
         if (permIndex.length > 0 || checkOwner) {
-            const addr = await LocalMark.Instance().get_account(account);
+            const addr = await Account.Instance().get(account);
             if (!addr) ERROR(Errors.InvalidParam, 'check_permission_and_call: account invalid');
 
-            const p = await query_permission({permission_object:permission, address:addr!});
+            const p = await query_permission({permission_object:permission, address:addr.address});
             if (checkOwner && !p.owner) ERROR(Errors.noPermission, 'owner');
             if (checkAdmin && !p.admin) ERROR(Errors.noPermission, 'admin');
 
@@ -117,7 +118,7 @@ export class CallBase {
             } 
             return {guard:[...guards], witness:p!.future_fills()};
         } else { // no passport needed
-            return await this.exec()
+            return await this.exec(account)
         }
     }
     protected async exec (account?:string) : Promise<CallResponse> {
@@ -128,20 +129,19 @@ export class CallBase {
 
     protected async new_with_mark(type:ObjectBaseType, txb:TransactionBlock, object:TxbAddress, named_new?:Namedbject, account?:string, innerTags:string[]=[TagName.Launch]) {
         const tags = named_new?.tags ? array_unique([...named_new.tags, ...innerTags]) : array_unique([...innerTags]);
-        if (!named_new?.onChain) {
-            if (named_new) {
-                named_new.tags = tags; 
-                this.traceMarkNew.set(type, named_new)
-            }
-            return ;
-        } ;
+        if (named_new) {
+            named_new.tags = tags; 
+            this.traceMarkNew.set(type, named_new)
+        }
+
+        if (!named_new?.onChain) return ;
 
         // onchain mark
         if (!this.resouceObject) {
-            const addr = await LocalMark.Instance().get_account(account);
+            const addr = await Account.Instance().get(account);
 
             if (addr) {
-                const r = await query_personal({address:addr}); //@ use cache
+                const r = await query_personal({address:addr.address}); //@ use cache
                 if (!r?.mark_object) {
                     this.resouceObject = Entity.From(txb).create_resource2(); // new 
                     Resource.From(txb, this.resouceObject).add(object, tags, named_new?.name);
@@ -154,20 +154,29 @@ export class CallBase {
         } else {
             Resource.From(txb, this.resouceObject).add(object, tags, named_new?.name);
         }
-    
     }
 
-    protected async sign_and_commit(txb: TransactionBlock, address?: string) : Promise<CallResponse> {
+    protected async update_content(object:string, type:ObjectBaseType)  {
+        if (this.content)   return ;
+
+        const r = await query_objects({objects:[object]});
+        if (r?.objects?.length !== 1 || r?.objects[0]?.type !== type) {
+            ERROR(Errors.Fail, `Fetch ${type} object ${object} failed`)
+        }
+
+        this.content = r?.objects[0];
+    }
+
+    protected async sign_and_commit(txb: TransactionBlock, account?: string) : Promise<CallResponse> {
         if (this.resouceObject) {
             Resource.From(txb, this.resouceObject).launch(); //@ resource launch, if created.
             this.resouceObject = undefined;
         }
-
-        const r = await Account.Instance().sign_and_commit(txb, address);
+        const r = await Account.Instance().sign_and_commit(txb, account);
+        
         if (!r) {
             ERROR(Errors.Fail, 'sign and commit failed');
         }
-        
         // save the mark locally, anyway
         const res = ResponseData(r);
         res.forEach(v => {
@@ -175,7 +184,7 @@ export class CallBase {
                 const namedNew = this.traceMarkNew.get(v.type);
                 if (namedNew) {
                     LocalMark.Instance().put(namedNew.name, 
-                        {object:v.object, tags:namedNew?.tags}, 
+                        {object:v.object, tags:namedNew?.tags ? [...namedNew?.tags, v.type] : [v.type]}, 
                         namedNew?.useAddressIfNameExist);
                 }
             }

package/src/call/call.ts

@@ -18,53 +18,53 @@ import { CallObjectPermission, CallObjectPermission_Data } from "./object_permis
 
 export interface CallDemandObject {
     data: CallDemand_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 
 export interface CallServiceObject {
     data: CallService_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 export interface CallMachineObject {
     data: CallMachine_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 export interface CallTreasuryObject {
     data: CallTreasury_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 export interface CallArbitrationObject {
     data: CallArbitration_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 export interface CallGuardObject {
     data: CallGuard_Data;
-    account?: string;
+    account?: string | null;
 }
 export interface CallRepositoryObject {
     data: CallRepository_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 export interface CallPersonalObject {
     data: CallPersonal_Data;
-    account?: string;
+    account?: string | null;
 }
 export interface CallPermissionObject {
     data: CallPermission_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 
 export interface CallTransferPermissionObject {
     data: CallObjectPermission_Data;
-    account?: string;
-    witness?: GuardInfo_forCall;
+    account?: string | null;
+    witness?: GuardInfo_forCall | null;
 }
 
 export const call_demand_json = async (json: string) : Promise<string> => {
@@ -151,49 +151,49 @@ export const call_guard_json = async (json: string) : Promise<string> => {
 
 export const call_demand = async (call:CallDemandObject) : Promise<CallResult> => {
     const obj = new CallDemand(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_service = async (call:CallServiceObject) : Promise<CallResult> => {
     const obj = new CallService(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_treasury = async (call:CallTreasuryObject) : Promise<CallResult> => {
     const obj = new CallTreasury(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_repository = async (call:CallRepositoryObject) : Promise<CallResult> => {
     const obj = new CallRepository(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_guard = async (call:CallGuardObject) : Promise<CallResult> => {
     const obj = new CallGuard(call.data);
-    return call_object(obj, call.account)
+    return await call_object(obj, call.account)
 }
 export const call_machine = async (call:CallMachineObject) : Promise<CallResult> => {
     const obj = new CallMachine(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_personal = async (call:CallPersonalObject) : Promise<CallResult> => {
     const obj = new CallPersonal(call.data);
-    return call_object(obj, call.account);
+    return await call_object(obj, call.account);
 }
 export const call_permission = async (call:CallPermissionObject) : Promise<CallResult> => {
     const obj = new CallPermission(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_transfer_permission = async (call:CallTransferPermissionObject) : Promise<CallResult> => {
     const obj = new CallObjectPermission(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 export const call_arbitration = async (call:CallArbitrationObject) : Promise<CallResult> => {
     const obj = new CallArbitration(call.data);
-    return call_object(obj, call.account, call.witness)
+    return await call_object(obj, call.account, call.witness)
 }
 
-const call_object = async (object: CallBase, account?: string, witness?: GuardInfo_forCall) : Promise<CallResult> => {
+const call_object = async (object: CallBase, account?: string | null, witness?: GuardInfo_forCall | null) : Promise<CallResult> => {
     if (witness) {
-        return object.call_with_witness(witness, account);
+        return await object.call_with_witness(witness, account ?? undefined);
     } else {
-        return object.call(account);
+        return await object.call(account ?? undefined);
     }
 }