wowok_agent 1.3.47 → 1.3.49

package/src/call/treasury.ts

@@ -1,9 +1,9 @@
 import { TransactionBlock, IsValidArgType, PassportObject, Errors, ERROR, Permission, PermissionIndex,
-    PermissionIndexType, Treasury, Treasury_WithdrawMode, WithdrawParam, 
+    PermissionIndexType, Treasury, Treasury_WithdrawMode, PermissionObject, 
 } from 'wowok';
 import { query_objects, ObjectTreasury, Treasury_ReceivedObject } from '../query/objects.js';
 import { AccountOrMark_Address, CallBase, CallResult, GetAccountOrMark_Address, GetObjectExisted, 
-    GetObjectMain, GetObjectParam, ObjectTypedMain, TypeNamedObjectWithPermission } from "./base.js";
+    GetObjectMain, GetObjectParam, ObjectTypedMain, PayParam, TypeNamedObjectWithPermission } from "./base.js";
 import { Account } from '../local/account.js';
 import { LocalMark } from '../local/local.js';
 import { get_object_address } from '../common.js';
@@ -13,7 +13,7 @@ export interface ReceiverParam {
     amount: string|number;
 }
 
-export interface TreasuryWithdrawParam extends WithdrawParam {
+export interface TreasuryWithdrawParam extends PayParam {
     receiver: ReceiverParam[];
     withdraw_guard?: string,
 }
@@ -21,7 +21,7 @@ export interface TreasuryWithdrawParam extends WithdrawParam {
 /// The execution priority is determined by the order in which the object attributes are arranged
 export interface CallTreasury_Data {
     object: ObjectTypedMain;
-    deposit?: {balance:string|number; index?:number|string; remark?:string; for_object?:string; for_guard?:string};
+    deposit?: {balance:string|number; param?:PayParam};
     receive?: {received_objects:string[]} | 'recently';
     withdraw?: TreasuryWithdrawParam;
 
@@ -41,24 +41,29 @@ export class CallTreasury extends CallBase {
         this.data = data;
     }
     
+    protected async prepare(): Promise<void> {
+        if (!this.object_address) {
+            this.object_address = (await LocalMark.Instance().get_address(GetObjectExisted(this.data.object)));
+            if (this.object_address) {
+                await this.update_content('Treasury', this.object_address);
+                if (!this.content) ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.object:' + this.object_address);
+                this.permission_address = (this.content as ObjectTreasury).permission;
+                this.type_parameter = Treasury.parseObjectType(this.content.type_raw);
+            } else {
+                const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
+                if (!IsValidArgType(n?.type_parameter)) {
+                    ERROR(Errors.IsValidArgType, 'CallTreasury_Data.data.object.type_parameter');
+                }          
+                this.permission_address = (await LocalMark.Instance().get_address(GetObjectExisted(n?.permission)));
+                this.type_parameter = n.type_parameter;
+            } 
+        }
+    }
     async call(account?:string) : Promise<CallResult>  {
         var checkOwner = false; const guards : string[] = [];
         const perms : PermissionIndexType[] = []; 
-        this.object_address = (await LocalMark.Instance().get_address(GetObjectExisted(this.data.object)));
-        if (this.object_address) {
-            await this.update_content('Treasury', this.object_address);
-            if (!this.content) ERROR(Errors.InvalidParam, 'CallArbitration_Data.data.object:' + this.object_address);
-            this.permission_address = (this.content as ObjectTreasury).permission;
-            this.type_parameter = Treasury.parseObjectType(this.content.type_raw);
-        } else {
-            const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
-            if (!IsValidArgType(n?.type_parameter)) {
-                ERROR(Errors.IsValidArgType, 'CallTreasury_Data.data.object.type_parameter');
-            }          
-            this.permission_address = (await LocalMark.Instance().get_address(GetObjectExisted(n?.permission)));
-            this.type_parameter = n.type_parameter;
-        } 
 
+        await this.prepare();
         if (this.permission_address) {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.treasury)
@@ -101,105 +106,111 @@ export class CallTreasury extends CallBase {
         return await this.exec(account);
     }
     protected async operate (txb:TransactionBlock, passport?:PassportObject, account?:string) {
-        let obj : Treasury | undefined ; let permission: any; 
+        let obj : Treasury | undefined ; let perm: Permission | undefined;
+        let permission : PermissionObject | undefined;
+
         if (this.object_address) {
-            obj = Treasury.From(txb, this.type_parameter!, this.permission_address!, this.object_address)
+            obj = Treasury.From(txb, this.type_parameter!, this.permission_address!, this.object_address);
+            permission = this.permission_address;
         } else {
             const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
-            if (!this.permission_address) {
-                permission = Permission.New(txb, GetObjectParam(n?.permission)?.description ?? '');
+            permission = await LocalMark.Instance().get_address(GetObjectExisted(n?.permission));
+            if (!permission) {
+                perm = Permission.New(txb, GetObjectParam(n?.permission)?.description ?? '');
+                permission =  perm.get_object();
             }
-            obj = Treasury.New(txb, this.type_parameter!, permission ? permission.get_object(): this.permission_address, 
-                this.data?.description??'', permission?undefined:passport)     
+
+            obj = Treasury.New(txb, this.type_parameter!, permission,
+                this.data?.description??'', perm?undefined:passport)     
         }
 
+        if (!obj) ERROR(Errors.InvalidParam, 'CallTreasury_Data.object:' + this.object_address);
+        if (!permission) ERROR(Errors.InvalidParam, 'CallTreasury_Data.permission:' + this.permission_address);
 
-        if (obj) {
-            const pst = permission?undefined:passport;
-            if (this.data.deposit !== undefined) {
-                const coin = await Account.Instance().get_coin_object(txb, this.data.deposit.balance, account, this.type_parameter);
-                if (coin) {
-                    const index = this.data.deposit?.index ?? 0;
-                    const [for_guard, for_object] = await LocalMark.Instance().get_many_address([this.data.deposit?.for_guard, this.data.deposit?.for_object])
-                    obj?.deposit({coin:coin, index:BigInt(index), remark:this.data.deposit.remark ??'', for_guard, for_object});
-                }
+        const pst = perm?undefined:passport;
+        if (this.data.deposit !== undefined) {
+            const coin = await Account.Instance().get_coin_object(txb, this.data.deposit.balance, account, this.type_parameter);
+            if (coin) {
+                const index = this.data.deposit?.param?.index ?? 0;
+                const [for_guard, for_object] = await LocalMark.Instance().get_many_address([this.data.deposit?.param?.for_guard, this.data.deposit?.param?.for_object])
+                obj?.deposit({coin:coin, index:BigInt(index), remark:this.data.deposit?.param?.remark ??'', for_guard, for_object});
             }
-            if (this.data?.receive !== undefined && this.object_address) {
-                if (this.data.receive === 'recently') {
-                    const r = await Treasury.GetTreasuryRecievedObject(this.object_address, this.type_parameter!);
-                    if (!r) {
-                        ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects');
-                    }
-                    r.received.forEach(v => {
-                        obj?.receive(v.payment, v.id, pst);
-                    })
-                } else if (this.data.receive?.received_objects?.length > 0) {
-                    const r = await query_objects({objects:this.data.receive.received_objects});
-                    if (r?.objects?.length!== this.data.receive.received_objects.length) {
-                        ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects');
-                    }
+        }
+        if (this.data?.receive !== undefined && this.object_address) {
+            if (this.data.receive === 'recently') {
+                const r = await Treasury.GetTreasuryRecievedObject(this.object_address, this.type_parameter!);
+                if (!r) {
+                    ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects');
+                }
+                r.received.forEach(v => {
+                    obj?.receive(v.payment, v.id, pst);
+                })
+            } else if (this.data.receive?.received_objects?.length > 0) {
+                const r = await query_objects({objects:this.data.receive.received_objects});
+                if (r?.objects?.length!== this.data.receive.received_objects.length) {
+                    ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects');
+                }
 
-                    for (let i=0; i<r?.objects?.length; ++i) {
-                        if (r.objects[i].type !== 'Treasury_ReceivedObject') {
-                            ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects:'+ r.objects[i].object);
-                        }
-                        const v = r.objects[i] as Treasury_ReceivedObject;
-                        obj?.receive(v.payment, v.object, pst);
+                for (let i=0; i<r?.objects?.length; ++i) {
+                    if (r.objects[i].type !== 'Treasury_ReceivedObject') {
+                        ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.receive.received_objects:'+ r.objects[i].object);
                     }
+                    const v = r.objects[i] as Treasury_ReceivedObject;
+                    obj?.receive(v.payment, v.object, pst);
                 }
             }
+        }
 
-            if (this.data?.withdraw !== undefined) {
-                const [for_guard, for_object] = await LocalMark.Instance().get_many_address([this.data.withdraw?.for_guard, this.data.withdraw?.for_object]);
-                const receiver = [];
-                for (let i=0;i < this.data.withdraw.receiver.length; ++i) {
-                    const v = this.data.withdraw.receiver[i];
-                    const address = await GetAccountOrMark_Address(v.address);
-                    if (!address) ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.withdraw.receiver:'+ v.address);
+        if (this.data?.withdraw !== undefined) {
+            const [for_guard, for_object] = await LocalMark.Instance().get_many_address([this.data.withdraw?.for_guard, this.data.withdraw?.for_object]);
+            const receiver = [];
+            for (let i=0;i < this.data.withdraw.receiver.length; ++i) {
+                const v = this.data.withdraw.receiver[i];
+                const address = await GetAccountOrMark_Address(v.address);
+                if (!address) ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.withdraw.receiver:'+ v.address);
 
-                    receiver.push({address:address, amount:BigInt(v.amount)})
-                }
-                obj?.withdraw({items:receiver, index:this.data.withdraw.index ?? 0, remark:this.data.withdraw.remark??'',
-                    for_guard, for_object, withdraw_guard: await LocalMark.Instance().get_address(this.data.withdraw.withdraw_guard)}, pst);
+                receiver.push({address:address, amount:BigInt(v.amount)})
             }
+            obj?.withdraw({items:receiver, index:this.data.withdraw.index ?? 0, remark:this.data.withdraw.remark??'',
+                for_guard, for_object, withdraw_guard: await LocalMark.Instance().get_address(this.data.withdraw.withdraw_guard)}, pst);
+        }
 
-            if (this.data?.description !== undefined && this.object_address) {
-                obj?.set_description(this.data.description, pst);
-            }
-            if (this.data?.deposit_guard !== undefined) {
-                const guard = await LocalMark.Instance().get_address(this.data?.deposit_guard);
-                obj?.set_deposit_guard(guard, pst);
-            }
-            if (this.data?.withdraw_guard !== undefined) {
-                switch (this.data.withdraw_guard.op) {
-                    case 'add':
-                    case 'set':
-                        if (this.data.withdraw_guard.op === 'set') obj?.remove_withdraw_guard([], true, pst);
-                        for (let i = 0; i < this.data.withdraw_guard.data.length; ++ i) {
-                            let v = this.data.withdraw_guard.data[i];
-                            const guard = await LocalMark.Instance().get_address(v.guard);
-                            if (guard) obj?.add_withdraw_guard(guard, BigInt(v.amount), pst);
-                        }
-                        break;
-                    case 'remove':
-                        obj?.remove_withdraw_guard(await LocalMark.Instance().get_many_address2(this.data.withdraw_guard.guards), false, pst)
-                        break;
+        if (this.data?.description !== undefined && this.object_address) {
+            obj?.set_description(this.data.description, pst);
+        }
+        if (this.data?.deposit_guard !== undefined) {
+            const guard = await LocalMark.Instance().get_address(this.data?.deposit_guard);
+            obj?.set_deposit_guard(guard, pst);
+        }
+        if (this.data?.withdraw_guard !== undefined) {
+            switch (this.data.withdraw_guard.op) {
+                case 'add':
+                case 'set':
+                    if (this.data.withdraw_guard.op === 'set') obj?.remove_withdraw_guard([], true, pst);
+                    for (let i = 0; i < this.data.withdraw_guard.data.length; ++ i) {
+                        let v = this.data.withdraw_guard.data[i];
+                        const guard = await LocalMark.Instance().get_address(v.guard);
+                        if (guard) obj?.add_withdraw_guard(guard, BigInt(v.amount), pst);
+                    }
+                    break;
+                case 'remove':
+                    obj?.remove_withdraw_guard(await LocalMark.Instance().get_many_address2(this.data.withdraw_guard.guards), false, pst)
+                    break;
 
-                    case 'removeall':
-                        obj?.remove_withdraw_guard([], true, pst)
-                        break;
-                }
+                case 'removeall':
+                    obj?.remove_withdraw_guard([], true, pst)
+                    break;
             }
-            if (this.data?.withdraw_mode !== undefined) {
-                obj?.set_withdraw_mode(this.data.withdraw_mode, pst)
-            }
-            if (permission) {
-                const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
-                await this.new_with_mark('Permission', txb, permission.launch(), GetObjectParam(n?.permission), account);
-            }
-            if (!this.object_address) {
-                await this.new_with_mark('Treasury', txb, obj.launch(), GetObjectMain(this.data?.object), account);
-            } 
         }
+        if (this.data?.withdraw_mode !== undefined) {
+            obj?.set_withdraw_mode(this.data.withdraw_mode, pst)
+        }
+        if (perm) {
+            const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
+            await this.new_with_mark('Permission', txb, perm.launch(), GetObjectParam(n?.permission), account);
+        }
+        if (!this.object_address) {
+            await this.new_with_mark('Treasury', txb, obj.launch(), GetObjectMain(this.data?.object), account);
+        } 
     }
 }

package/src/index.ts

@@ -18,5 +18,6 @@ export * from './local/cache.js'
 export * from './local/local.js'
 export * from './local/index.js'
 export * from './common.js'
+export * from './query/treasury_received.js'
 
 export * as WOWOK from 'wowok'

package/src/query/objects.ts

@@ -5,10 +5,11 @@
 
 import { Protocol, Machine_Node, Machine, Treasury_WithdrawMode, Treasury_Operation,
     Repository_Type, Repository_Policy_Mode, Repository_Policy, Service_Discount_Type, Service_Sale,
-    Progress, History, ERROR, Errors, IsValidAddress, Bcs, Entity_Info, Tags, uint2address,
-    TreasuryReceivedObject} from 'wowok';
-import { CacheExpireType, CacheName, CachedData, Cache } from '../local/cache.js'
+    Progress, History, ERROR, Errors, Bcs, Entity_Info, Tags, uint2address,
+} from 'wowok';
+import { CacheExpireType, CacheName, Cache } from '../local/cache.js'
 import { LocalMark } from '../local/local.js';
+import { AccountOrMark_Address, GetAccountOrMark_Address } from '../call/base.js';
 
 export type ObjectBaseType = 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' | 'Discount' |
         'Personal' | 'Permission' | 'PersonalMark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
@@ -246,7 +247,7 @@ export interface ObjectsQuery {
 }
 
 export interface PersonalQuery {
-    address: string;
+    address: AccountOrMark_Address;
     no_cache?: boolean;
 }
 export interface ObjectsAnswer {
@@ -351,15 +352,14 @@ export const query_objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer
 }
 
 export const query_personal = async (query:PersonalQuery) : Promise<ObjectPersonal | undefined> => {
-    const addr = await LocalMark.Instance().get_address(query.address);
+    const addr = await GetAccountOrMark_Address(query.address);
     if (!addr)  {
-        ERROR(Errors.InvalidParam, 'query_personal.query.address')
+        ERROR(Errors.InvalidParam, 'query_personal.address')
     }
-    query.address = addr;
 
     if (!query.no_cache) {
         try {
-            const cache = await Cache.Instance().cache_get(query.address, CacheName.personal);
+            const cache = await Cache.Instance().cache_get(addr, CacheName.personal);
             if (cache) {
                 const d = JSON.parse(cache.data) as ObjectPersonal;
                 d.cache_expire = cache.expire;  
@@ -367,9 +367,9 @@ export const query_personal = async (query:PersonalQuery) : Promise<ObjectPerson
             }                 
         } catch (e) {/*console.log(e)*/}
     } 
-    const res = await tableItemQuery_byAddress({parent:Protocol.Instance().objectEntity(), address:query.address});
+    const res = await tableItemQuery_byAddress({parent:Protocol.Instance().objectEntity(), address:addr});
     if (res.type === 'Personal') {
-        await Cache.Instance().put(query.address, {expire:Cache.ExpireTime(), data:JSON.stringify(res)}, CacheName.personal);
+        await Cache.Instance().put(addr, {expire:Cache.ExpireTime(), data:JSON.stringify(res)}, CacheName.personal);
         return res as ObjectPersonal;
     }
 }

package/src/query/permission.ts

@@ -3,12 +3,13 @@
  * not only the permission table, but also the administrator or Builder identity.
  */
 
+import { AccountOrMark_Address, GetAccountOrMark_Address } from '../call/base.js';
 import { LocalMark } from '../local/local.js';
-import { TransactionBlock, Protocol, Bcs, IsValidAddress, Errors, ERROR, Permission, PermissionAnswer, BCS} from 'wowok';
+import { TransactionBlock, Protocol, Bcs, Errors, ERROR, Permission, PermissionAnswer, BCS} from 'wowok';
 
 export interface PermissionQuery {
-    object_address_or_name: string;
-    entity_address_or_name: string;
+    permission_object: string;
+    address: AccountOrMark_Address;
 }
 
 /*json: PermissionQuery; return PermissionAnswer */
@@ -22,11 +23,13 @@ export const query_permission_json = async (json:string) : Promise<string> => {
 }
 
 export const query_permission = async (query:PermissionQuery) : Promise<PermissionAnswer> => {
-    const object_address = await LocalMark.Instance().get_address(query.object_address_or_name);
-    const entity_address = await LocalMark.Instance().get_address(query.entity_address_or_name);
+    const [object_address, entity_address] = await Promise.all([
+        LocalMark.Instance().get_address(query.permission_object),
+        GetAccountOrMark_Address(query.address),
+    ]);
 
     if (!object_address || !entity_address) {
-        ERROR(Errors.InvalidParam, 'query.object_address_or_name or query.entity_address_or_name');
+        ERROR(Errors.InvalidParam, 'permission.query_permission');
     }
     
     const txb = new TransactionBlock();

package/src/query/treasury_received.ts

@@ -0,0 +1,35 @@
+import { ERROR, Errors, Protocol, Treasury, TreasuryReceived, TreasuryReceivedObject } from "wowok";
+import { query_objects, Treasury_ReceivedObject } from "./objects.js";
+
+
+export interface QueryTreasuryReceived {
+    /** Name or address of the Treasury object. */
+    treasury_object: string;
+    /**
+     * An optional paging cursor. If provided, the query will start from the next item after the specified
+     * cursor. Default to start from the first item if not specified.
+     */
+    cursor?: string | null | undefined;
+    /** Max number of items returned per page, default to [QUERY_MAX_RESULT_LIMIT] if not specified. */
+    limit?: number | null | undefined;
+}
+
+export const query_treasury_received = async (query: QueryTreasuryReceived) : Promise<TreasuryReceived> => {
+    const r1 = await query_objects({objects:[query.treasury_object]});
+    if (r1?.objects?.length !== 1 || r1.objects[0].type !== 'Treasury') {
+        ERROR(Errors.InvalidParam, 'query_treasury_received: invalid treasury_object');
+    }
+
+    const type = Protocol.Instance().package('wowok')+'::payment::CoinWrapper<'+Treasury.parseObjectType(r1.objects[0].type_raw)+'>';
+    const r2 = await Protocol.Client().getOwnedObjects({owner:r1.objects[0].object, filter:{StructType: type}, 
+        options:{showContent:true, showType:true}, cursor:query.cursor, limit:query.limit});
+
+    let receive = BigInt(0);
+    const res: TreasuryReceivedObject[] = r2.data.map((v:any) => {
+    const i = v?.data?.content?.fields;
+    receive += BigInt(i?.coin?.fields?.balance);
+    return {payment:i?.payment, balance:i?.coin?.fields?.balance, id:v?.data?.objectId} 
+    });
+
+    return {balance:receive.toString(), received:res};    
+}