wowok_agent 1.2.44 → 1.3.47

package/src/call/treasury.ts

@@ -1,63 +1,69 @@
-import { TransactionBlock, IsValidArgType, PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex,
+import { TransactionBlock, IsValidArgType, PassportObject, Errors, ERROR, Permission, PermissionIndex,
     PermissionIndexType, Treasury, Treasury_WithdrawMode, WithdrawParam, 
 } from 'wowok';
-import { query_objects, ObjectTreasury } from '../query/objects.js';
-import { CallBase, CallResult, Namedbject } from "./base.js";
+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";
 import { Account } from '../local/account.js';
 import { LocalMark } from '../local/local.js';
 import { get_object_address } from '../common.js';
 
+export interface ReceiverParam {
+    address: AccountOrMark_Address;
+    amount: string|number;
+}
+
+export interface TreasuryWithdrawParam extends WithdrawParam {
+    receiver: ReceiverParam[];
+    withdraw_guard?: string,
+}
+
 /// The execution priority is determined by the order in which the object attributes are arranged
 export interface CallTreasury_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}; 
+    object: ObjectTypedMain;
+    deposit?: {balance:string|number; index?:number|string; remark?:string; for_object?:string; for_guard?:string};
+    receive?: {received_objects:string[]} | 'recently';
+    withdraw?: TreasuryWithdrawParam;
+
     description?: string;
-    deposit?: {data:{balance:string|number; index?:number|string; remark?:string; for_object?:string; for_guard?:string}; guard?:string};
-    receive?: {payment:string; received_object:string};
-    withdraw?: WithdrawParam;
     deposit_guard?: string;
     withdraw_guard?: {op:'add' | 'set'; data:{guard:string, amount:string|number}[]} | {op:'remove', guards:string[]} | {op:'removeall'};
     withdraw_mode?: Treasury_WithdrawMode;
 }
 export class CallTreasury extends CallBase {
     data: CallTreasury_Data;
+    object_address: string | undefined = undefined;
+    permission_address: string | undefined = undefined;
+    type_parameter: string | undefined = undefined; 
+
     constructor(data:CallTreasury_Data) {
         super();
         this.data = data;
     }
     
     async call(account?:string) : Promise<CallResult>  {
-        if (!this.data.type_parameter || !IsValidArgType(this.data.type_parameter)) {
-            ERROR(Errors.IsValidArgType, 'treasury.type_parameter');
-        }
-
         var checkOwner = false; const guards : string[] = [];
-        const perms : PermissionIndexType[] = [];  var obj: ObjectTreasury | undefined ;
-        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]);
-
-        if (object_address) {
-            if (!this.data.type_parameter || !permission_address) {
-                await this.update_content(object_address, 'Treasury');
-                if (this.content) {
-                    permission_address = (this.content as ObjectTreasury).permission;     
-                    this.data.type_parameter =  this.content.type_raw!;             
-                }
-            } 
+        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 {
-            if (!this.data?.type_parameter || !IsValidArgType(this.data.type_parameter)) {
-                ERROR(Errors.IsValidArgType, 'CallTreasury_Data.data.type_parameter')
-            }
-        }
+            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;
+        } 
 
-        if (permission_address) {
+        if (this.permission_address) {
             if (!this.data?.object) {
                 perms.push(PermissionIndex.treasury)
             }
-            if (this.data?.description !== undefined && object_address) {
+            if (this.data?.description !== undefined && this.object_address) {
                 perms.push(PermissionIndex.treasury_descritption)
             }
             if (this.data?.withdraw_mode !== undefined) {
@@ -73,23 +79,9 @@ export class CallTreasury extends CallBase {
                 perms.push(PermissionIndex.treasury_deposit_guard)
             }
             if (this.data?.deposit !== undefined) {
-                if (this.data.deposit.guard) {
-                    const guard = await LocalMark.Instance().get_address(this.data?.deposit?.guard);
-                    if (guard) {
-                        guards.push(guard)
-                    }
-                } else {
-                    if (!object_address) {
-                        const guard = await LocalMark.Instance().get_address(this.data.deposit_guard);
-                        if (guard) {
-                            guards.push(guard);
-                        }
-                    } else {
-                        await this.update_content(object_address, 'Treasury');
-    
-                        if ((this.content as ObjectTreasury)?.deposit_guard) {
-                            guards.push((this.content as ObjectTreasury).deposit_guard!)
-                        }                         
+                if (this.object_address) {
+                    if ((this.content as ObjectTreasury)?.deposit_guard) {
+                        guards.push((this.content as ObjectTreasury).deposit_guard!)
                     }
                 }
             }
@@ -104,59 +96,76 @@ export class CallTreasury extends CallBase {
             } else { // withdraw with permission
                 perms.push(PermissionIndex.treasury_withdraw)
             }
-            return await this.check_permission_and_call(permission_address, perms, guards, checkOwner, undefined, account)
+            return await this.check_permission_and_call(this.permission_address, perms, guards, checkOwner, undefined, account)
         }
         return await this.exec(account);
     }
     protected async operate (txb:TransactionBlock, passport?:PassportObject, account?:string) {
         let obj : Treasury | undefined ; let permission: any; 
-        var [permission_address, object_address] = this?.content ? 
-            [(this.content as ObjectTreasury).permission, this.content.object] : 
-            await LocalMark.Instance().get_many_address(
-                [(this.data?.permission as any)?.address, 
-                (this.data?.object as any)?.address]);
-
-        if (!object_address) {
-            if (!permission_address) {
-                const d = (this.data?.permission as any)?.description ?? '';
-                permission = Permission.New(txb, d);
-            }
-            obj = Treasury.New(txb, this.data.type_parameter!, permission ? permission.get_object() : permission_address, this.data?.description??'', permission?undefined:passport)
+        if (this.object_address) {
+            obj = Treasury.From(txb, this.type_parameter!, this.permission_address!, this.object_address)
         } else {
-            if (this.data.type_parameter && permission_address) {
-                obj = Treasury.From(txb, this.data.type_parameter, permission_address, object_address)
-            } else {
-                ERROR(Errors.InvalidParam, 'CallTreasury_Data.data.type_parameter or permission')
+            const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
+            if (!this.permission_address) {
+                permission = Permission.New(txb, GetObjectParam(n?.permission)?.description ?? '');
             }
+            obj = Treasury.New(txb, this.type_parameter!, permission ? permission.get_object(): this.permission_address, 
+                this.data?.description??'', permission?undefined:passport)     
         }
 
+
         if (obj) {
             const pst = permission?undefined:passport;
-            if (this.data?.description !== undefined && object_address) {
-                obj?.set_description(this.data.description, pst);
-            }
             if (this.data.deposit !== undefined) {
-                const coin = await Account.Instance().get_coin_object(txb, this.data.deposit.data.balance, account, this.data.type_parameter);
+                const coin = await Account.Instance().get_coin_object(txb, this.data.deposit.balance, account, this.type_parameter);
                 if (coin) {
-                    const index = this.data.deposit.data?.index ?? 0;
-                    obj?.deposit({coin:coin, index:BigInt(index), remark:this.data.deposit.data.remark ??'', 
-                        for_guard:await get_object_address(this.data.deposit.data?.for_guard),
-                        for_object:await get_object_address(this.data.deposit.data?.for_object)
-                    })
+                    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});
                 }
             }
-            if (this.data?.receive !== undefined) {
-                const [payment, receive] = await LocalMark.Instance().get_many_address([this.data.receive.payment, this.data.receive.received_object])
-                if (payment && receive) obj?.receive(payment, receive, pst); 
+            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);
+                    }
+                }
             }
 
             if (this.data?.withdraw !== undefined) {
-                this.data.withdraw.for_guard = await get_object_address(this.data.withdraw.for_guard);
-                this.data.withdraw.for_object = await get_object_address(this.data.withdraw.for_object);
-                this.data.withdraw.withdraw_guard = await get_object_address(this.data.withdraw.withdraw_guard);
-                obj?.withdraw(this.data.withdraw, pst)
+                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);
             }
 
+            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);
@@ -185,10 +194,11 @@ export class CallTreasury extends CallBase {
                 obj?.set_withdraw_mode(this.data.withdraw_mode, pst)
             }
             if (permission) {
-                await this.new_with_mark('Permission', txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);
+                const n = GetObjectMain(this.data.object) as TypeNamedObjectWithPermission;
+                await this.new_with_mark('Permission', txb, permission.launch(), GetObjectParam(n?.permission), account);
             }
-            if (!object_address) {
-                await this.new_with_mark('Treasury', txb, obj.launch(), (this.data?.object as any)?.namedNew, account);
+            if (!this.object_address) {
+                await this.new_with_mark('Treasury', txb, obj.launch(), GetObjectMain(this.data?.object), account);
             } 
         }
     }

package/src/common.ts

@@ -1,5 +1,5 @@
 import { LocalMark } from "./local/local.js";
-
+import NodeRSA from 'node-rsa';
 
 export const isBrowser = ()  => {
     return typeof window !== 'undefined' && typeof indexedDB !== 'undefined';
@@ -11,4 +11,10 @@ export const get_object_address = async (object: any) => {
     } else {
         return object
     }
+}
+
+export const crypto_string = (str: string, pubkey:string) : string => {
+    const rsa = new NodeRSA();
+    rsa.importKey(pubkey, 'pkcs8-public-pem');
+    return rsa.encrypt(str, 'base64');
 }

package/src/local/account.ts

@@ -255,7 +255,7 @@ export class Account {
 
     get_coin_object = async (txb: TransactionBlock, balance_required:string | bigint | number, address_or_name?:string, token_type?:string) : Promise<TransactionResult | undefined> => {
         const a = await this.get(address_or_name);
-
+        
         if (a) {
             const b = BigInt(balance_required);
 

package/src/local/local.ts

@@ -80,7 +80,11 @@ export class LocalMark {
       return name
     }
 
-    async get(name: string) : Promise<MarkData | undefined> {
+    async get(name?: string) : Promise<MarkData | undefined> {
+      if (name === undefined || name === null) {
+        return undefined;
+      }
+
       const r = await this.storage.get(name);
       if (r) {
           return JSON.parse(r);
@@ -117,7 +121,7 @@ export class LocalMark {
     }
 
     async get_many_address2(name_or_addresses: (string | null | undefined)[]) : Promise<string[]> {
-      return (await this.get_many_address(name_or_addresses)).filter(v => v!==undefined && v!== null) as string[]
+      return (await this.get_many_address(name_or_addresses)).filter((v):v is string => v!==undefined && v!== null) as string[]
     }
 
     async del(name:string)  {

package/src/query/events.ts

@@ -54,7 +54,7 @@ export interface EventCursor {
     txDigest: string
 }
 export interface EventQuery {
-    type: 'OnNewArb' | 'OnPresentService' | 'OnNewProgress' | 'OnNewOrder';
+    type: 'OnNewArb' | 'OnPresentService' | 'OnNewProgress' | 'OnNewOrder' |  string;
     /** optional paging cursor */
     cursor?: EventCursor | null | undefined;
     /** maximum number of items per page, default to [QUERY_MAX_RESULT_LIMIT] if not specified. */
@@ -73,15 +73,17 @@ export const query_events_json = async (json:string) : Promise<string> => {
 }
 
 export const query_events = (query: EventQuery) : Promise<EventAnswer | undefined> => {
-    switch(query.type) {
-        case 'OnNewArb':
-            return newArbEvents(query.cursor, query.limit, query.order)
-        case 'OnNewProgress':
-            return newProgressEvents(query.cursor, query.limit, query.order)
-        case 'OnPresentService':
-            return presentServiceEvents(query.cursor, query.limit, query.order)
-        case 'OnNewOrder':
-            return newOrderEvents(query.cursor, query.limit, query.order)
+    const type = query.type.toLowerCase();
+    if (type.includes('arb') || type.includes('arbitration')) {
+        return newArbEvents(query.cursor, query.limit, query.order)
+    } else if (type.includes('present') || type.includes('demand')) {
+        return newProgressEvents(query.cursor, query.limit, query.order)
+    } else if (type.includes('progress') || type.includes('machine')) {
+        return presentServiceEvents(query.cursor, query.limit, query.order)
+    } else if (type.includes('order') || type.includes('service')) {
+        return newOrderEvents(query.cursor, query.limit, query.order)
+    } else {
+        return Promise.resolve(undefined);
     }
 }
 

package/src/query/objects.ts

@@ -5,14 +5,15 @@
 
 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} from 'wowok';
+    Progress, History, ERROR, Errors, IsValidAddress, Bcs, Entity_Info, Tags, uint2address,
+    TreasuryReceivedObject} from 'wowok';
 import { CacheExpireType, CacheName, CachedData, Cache } from '../local/cache.js'
 import { LocalMark } from '../local/local.js';
 
 export type ObjectBaseType = 'Demand' | 'Progress' | 'Service' | 'Machine' | 'Order' | 'Treasury' | 'Arbitration' | 'Arb' | 'Payment' | 'Guard' | 'Discount' |
         'Personal' | 'Permission' | 'PersonalMark' | 'Repository' | 'TableItem_ProgressHistory' | 'TableItem_PermissionEntity' | 
         'TableItem_DemandPresenter' | 'TableItem_MachineNode' | 'TableItem_ServiceSale' | 'TableItem_TreasuryHistory' | 'TableItem_ArbVote' |
-        'TableItem_RepositoryData' | 'TableItem_PersonalMark';
+        'TableItem_RepositoryData' | 'TableItem_PersonalMark' | 'Treasury_ReceivedObject';
 
 export interface ObjectBase {
     object: string;
@@ -23,6 +24,11 @@ export interface ObjectBase {
     cache_expire?: CacheExpireType;
 }
 
+export interface Treasury_ReceivedObject extends ObjectBase {
+    balance: string;
+    payment: string;
+}
+
 export interface ObjectPermission extends ObjectBase {
     builder: string;
     admin: string[];
@@ -107,7 +113,7 @@ export interface ObjectService extends ObjectBase {
     endpoint?: string | null;
     extern_withdraw_treasury: string[];
     machine?: string | null;
-    payee: string;
+    payee_treasury: string;
     repository: string[];
     sales_count: number;
     withdraw_guard: {guard:string, percent:number}[];
@@ -437,6 +443,7 @@ export interface QueryTableItem_AddressName {
     parent: string | ObjectRepository;
     address: string | number | bigint;
     name: string;
+    no_cache?: boolean;
 }
 export interface QueryTableItem_Address {
     parent: string | ObjectDemand | ObjectPermission | ObjectArb | ObjectMark;
@@ -508,7 +515,10 @@ export function raw2type(type_raw:string | undefined) : ObjectBaseType | undefin
         return t
     } else if (t === 'Resource') {
         return 'PersonalMark';
+    } else if (t === 'CoinWrapper') {
+        return 'Treasury_ReceivedObject';
     }
+
     const start = type_raw?.indexOf('0x2::dynamic_field::Field<');
     if (start === 0) {
         const end = type_raw?.substring('0x2::dynamic_field::Field<'.length);
@@ -611,7 +621,7 @@ export function data2object(data?:any) : ObjectBase {
                 object:id, type:type, type_raw:type_raw, owner:owner, version:version,
                 machine:content?.machine, permission:content?.permission, description:content?.description,
                 arbitration:content?.arbitrations, bPaused:content?.bPaused, bPublished:content?.bPublished,
-                buy_guard:content?.buy_guard, endpoint:content?.endpoint, payee:content?.payee, repository:content?.repositories, 
+                buy_guard:content?.buy_guard, endpoint:content?.endpoint, payee_treasury:content?.payee, repository:content?.repositories, 
                 withdraw_guard:content?.withdraw_guard?.fields?.contents?.map((v:any) => {
                     return {object:v?.fields?.key, percent:v?.fields?.value}
                 }),
@@ -749,6 +759,10 @@ export function data2object(data?:any) : ObjectBase {
             return {object:id, type:type, type_raw:type_raw, owner:owner, version:version,
                 address:content?.name, name:content?.value?.fields?.nick, tags:content?.value?.fields?.tags
             } as TableItem_PersonalMark;
+        case 'Treasury_ReceivedObject':
+            return { object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                balance: content.coin?.fields?.balance, payment:content?.payment
+            } as Treasury_ReceivedObject;
         }
     }