wowok_agent 0.0.1

package/src/call/permission.ts

@@ -0,0 +1,101 @@
+import { CallBase } from "./call";
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, Permission_Entity, Permission_Index, UserDefinedIndex,
+    PermissionIndexType, WitnessFill
+} from 'wowok';
+
+export class CallPermission extends CallBase {
+    builder?: string;
+    admin?: {op:'add' | 'remove' | 'set', admins:string[]};
+    description?: string;
+    entity?: {op:'add entity'; entities:Permission_Entity[]} | {op:'add permission'; permissions:Permission_Index[]} 
+        | {op:'remove entity'; addresses:string[]} | {op:'remove permission'; address:string; index:PermissionIndexType[]} 
+        | {op:'transfer permission', from_address: string; to_address: string};
+    biz_permission?: {op:'add'; data: UserDefinedIndex[]} | {op:'remove'; permissions: PermissionIndexType[]};
+    constructor(object: string | 'new' = 'new') { super(object) }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        var checkOwner = false; var checkAdmin = false;
+        if (this?.object !== 'new' && IsValidAddress(this?.object)) {
+            if (this?.builder !== undefined || this?.admin !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.entity !== undefined || this?.biz_permission !== undefined) {
+                checkAdmin = true;
+            }
+            if (this?.description !== undefined && this?.object !== 'new') {
+                checkAdmin = true;
+            }
+            return await this.check_permission_and_call(this.object, [], [], checkOwner, checkAdmin, account)
+        }
+        return this.exec(account)
+    }
+    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Permission | undefined ; 
+        if (this.object === 'new') {
+            obj = Permission.New(txb, this?.description??'');
+        } else {
+            if (IsValidAddress(this.object)) {
+                obj = Permission.From(txb, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.admin !== undefined) {
+                switch(this.admin.op) {
+                    case 'add':
+                        obj?.add_admin(this.admin.admins);
+                        break;
+                    case 'remove':
+                        obj?.remove_admin(this.admin.admins);
+                        break;
+                    case 'set':
+                        obj?.remove_admin([], true);
+                        obj?.add_admin(this.admin.admins);
+                        break
+                }
+            }
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description)
+            }
+            if (this?.entity !== undefined) {
+                switch (this.entity.op) {
+                    case 'add entity':
+                        obj?.add_entity(this.entity.entities);
+                        break;
+                    case 'add permission':
+                        obj?.add_entity3(this.entity.permissions);
+                        break;
+                    case 'remove entity':
+                        obj?.remove_entity(this.entity.addresses);
+                        break;
+                    case 'remove permission':
+                        obj?.remove_index(this.entity.address, this.entity.index);
+                        break;
+                    case 'transfer permission':
+                        obj?.transfer_permission(this.entity.from_address, this.entity.to_address);
+                        break;
+                }
+            }
+            if (this?.biz_permission !== undefined) {
+                switch(this.biz_permission.op) {
+                    case 'add':
+                        this.biz_permission.data.forEach(v => {
+                            obj?.add_userdefine(v.index, v.name);
+                        })
+                        break;
+                    case 'remove':
+                        this.biz_permission.permissions.forEach(v => {
+                            obj?.remove_userdefine(v);
+                        })
+                        break;
+                }
+            }
+            if (this?.builder !== undefined ) {
+                obj?.change_owner(this.builder);
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}

package/src/call/personal.ts

@@ -0,0 +1,87 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Entity, Entity_Info, MarkName, Resource, WitnessFill} from 'wowok';
+import { CallBase } from "./call";
+
+export class CallPersonal extends CallBase {
+    information?: Entity_Info;
+    transfer_to?: string;
+    marks?: {op:'add mark'; data:{mark_name:string; address:string[]}}
+        | {op:'add address'; data:{address:string; mark_name:string[]}} 
+        | {op:'remove mark'; data:{mark_name:string; address:string[]}}
+        | {op:'remove address'; data:{address:string; mark_name:string[]}}
+        | {op:'clear mark'; mark_name:string};
+    tags?: {op:'add'; data:{address:string; nick_name:string; tags:string[]}}
+        | {op:'remove'; address:string};
+    close?: boolean; // close a personal resource
+    constructor(object: string | 'new' = 'new') { super(object) }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        return this.exec(account)
+    }
+    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Resource | undefined ; let entity: Entity = Entity.From(txb);
+        if (this.object === 'new') {
+            obj = Resource.From(txb, entity.create_resource2());
+        } else {
+            if (IsValidAddress(this.object)) {
+                obj = Resource.From(txb, this.object)
+                if (this?.close) {
+                    entity.destroy_resource(obj)
+                    return ; //@ return 
+                }
+            }
+        }
+
+        if (this?.information !== undefined ) {
+            entity.update(this.information)
+        }
+
+        if (obj && obj?.get_object()) {
+            if (this?.marks !== undefined) {
+                switch(this.marks.op) {
+                    case 'add address':
+                        obj?.add2(this.marks.data.address, this.marks.data.mark_name)
+                        break;
+                    case 'add mark':
+                        if (this.marks.data.mark_name === MarkName.DislikeName || this.marks.data.mark_name === MarkName.LikeName) {
+                            const n = this.marks.data.mark_name;
+                            this.marks.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
+                        } else {
+                            obj?.add(this.marks.data.mark_name, this.marks.data.address)
+                        }
+                        break;
+                    case 'clear mark':
+                        obj?.remove(this.marks.mark_name, [], true)
+                        break;
+                    case 'remove address':
+                        obj?.remove2(this.marks.data.address, this.marks.data.mark_name)
+                        break;
+                    case 'remove mark':
+                        if (this.marks.data.mark_name === MarkName.DislikeName || this.marks.data.mark_name === MarkName.LikeName) {
+                            const n = this.marks.data.mark_name;
+                            this.marks.data.address.forEach(v => {if (obj) entity.mark(obj, v, n)})
+                        } else {
+                            obj?.remove(this.marks.data.mark_name, this.marks.data.address)
+                        }
+                        break;
+                }
+            }
+            if (this?.tags !== undefined) {
+                switch(this.tags.op) {
+                    case 'add':
+                        obj?.add_tags(this.tags.data.address, this.tags.data.nick_name, this.tags.data.tags)
+                        break;
+                    case 'remove':
+                        obj?.remove_tags(this.tags.address)
+                        break;
+                }
+            }
+            if (this?.transfer_to !== undefined && obj) {
+                entity.transfer_resource(obj, this.transfer_to);
+            }
+
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}

package/src/call/repository.ts

@@ -0,0 +1,129 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Repository,
+    Repository_Policy, Repository_Policy_Data, Repository_Policy_Data2, Repository_Policy_Data_Remove,
+    Repository_Policy_Mode, WitnessFill
+} from 'wowok';
+import { CallBase } from "./call";
+
+export class CallRepository extends CallBase {
+    permission_new?: string; // change permission or 'new' object with permission specified.
+    description?: string;
+    mode?: Repository_Policy_Mode; // default: 'Relax' (POLICY_MODE_FREE) 
+    reference?: {op:'set' | 'add' | 'remove' ; addresses:string[]} | {op:'removeall'};
+    policy?: {op:'add' | 'set'; data:Repository_Policy[]} | {op:'remove'; data:string[]} | {op:'removeall'} | {op:'rename'; data:{old:string; new:string}[]};
+    data?: {op:'add', data: Repository_Policy_Data | Repository_Policy_Data2} | {op:'remove'; data: Repository_Policy_Data_Remove};
+    constructor(object: string | 'new' = 'new') { super(object) }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        var checkOwner = false;
+        const perms : PermissionIndexType[] = []; 
+
+        if (this?.permission && IsValidAddress(this.permission)) {
+            if (this?.object === 'new') {
+                perms.push(PermissionIndex.repository)
+            }
+            if (this?.permission_new !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.description !== undefined && this?.object !== 'new') {
+                perms.push(PermissionIndex.repository_description)
+            }
+            if (this?.mode !== undefined && this?.object !== 'new') {
+                perms.push(PermissionIndex.repository_mode)
+            }
+            if (this?.reference !== undefined) {
+                perms.push(PermissionIndex.repository_reference)
+            }
+            if (this?.policy !== undefined) {
+                perms.push(PermissionIndex.repository_policies)
+            }
+            return await this.check_permission_and_call(this.permission, perms, [], checkOwner, undefined, account)
+        }
+        return this.exec(account);
+    }
+
+    protected async operate(txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Repository | undefined ; let permission: any;
+        if (this.object === 'new') {
+            if (!this?.permission || !IsValidAddress(this?.permission)) {
+                permission = Permission.New(txb, '');
+            }
+            
+            obj = Repository.New(txb, permission ?? this?.permission, this?.description??'', this?.mode, permission?undefined:passport)
+        } else {
+            if (IsValidAddress(this.object) && this.permission && IsValidAddress(this?.permission)) {
+                obj = Repository.From(txb, this.permission, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description, passport);
+            }
+            if (this?.mode !== undefined && this.object !== 'new') {
+                obj?.set_policy_mode(this.mode, passport)
+            }
+            if (this?.reference !== undefined) {
+                switch (this.reference.op) {
+                    case 'set':
+                        obj?.remove_reference([], true, passport);
+                        obj?.add_reference(this.reference.addresses, passport);
+                        break;
+                    case 'add':
+                        obj?.add_reference(this.reference.addresses, passport);
+                        break;
+                    case 'remove':
+                        obj?.remove_reference(this.reference.addresses, false, passport);
+                        break;
+                    case 'removeall':
+                        obj?.remove_reference([], true, passport);
+                        break;
+                }
+            }
+            if (this?.policy !== undefined) {
+                switch(this.policy.op) {
+                    case 'set':
+                        obj?.remove_policies([], true, passport);
+                        obj?.add_policies(this.policy.data, passport);
+                        break;
+                    case 'add':
+                        obj?.add_policies(this.policy.data, passport);
+                        break;
+                    case 'remove':
+                        obj?.remove_policies(this.policy.data, false, passport);
+                        break;
+                    case 'removeall':
+                        obj?.remove_policies([], true, passport);
+                        break;
+                    case 'rename':
+                        this.policy.data.forEach((v) => {
+                            obj?.rename_policy(v.old, v.new, passport);
+                        })
+                        break;
+                }
+            }
+            if (this?.data !== undefined) {
+                switch(this.data.op) {
+                    case 'add':
+                        if ((this.data?.data as any)?.key !== undefined) {
+                            obj?.add_data(this.data.data as Repository_Policy_Data);
+                        } else if ((this.data?.data as any)?.address !== undefined) {
+                            obj?.add_data2(this.data.data as Repository_Policy_Data2);
+                        }
+                        break;
+                    case 'remove':
+                        obj?.remove(this.data.data.address, this.data.data.key);
+                        break;
+                }
+            }
+            if (this?.permission_new !== undefined ) {
+                obj?.change_permission(this.permission_new);
+            }
+            if (permission) {
+                permission.launch();
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    };
+}

package/src/call/service.ts

@@ -0,0 +1,334 @@
+import { TransactionBlock, CallResponse} from 'wowok';
+import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex,
+    PermissionIndexType,  BuyRequiredEnum, Customer_RequiredInfo, DicountDispatch, Service, Service_Buy, 
+    Service_Guard_Percent, Service_Sale, WithdrawPayee, Treasury, WitnessFill
+} from 'wowok';
+import { OBJECT_QUERY, ObjectService } from '../objects';
+import { CallBase } from "./call";
+
+export class CallService extends CallBase {
+    type_parameter: string;
+    permission_new?: string;
+    bPaused?: boolean;
+    bPublished?: boolean;
+    description?: string;
+    gen_discount?: DicountDispatch[];
+    arbitration?: {op:'set' | 'add'; arbitrations:{address:string, token_type:string}[]} 
+        | {op:'removeall'} | {op:'remove', addresses:string[]};
+    buy_guard?: string;
+    endpoint?: string;
+    extern_withdraw_treasury?: {op:'set' | 'add'; treasuries:{address:string, token_type:string}[]} 
+        | {op:'removeall'} | {op:'remove', addresses:string[]};
+    machine?: string;
+    payee_treasury?:string;
+    clone_new?: {token_type_new?:string};
+    repository?: {op:'set' | 'add' | 'remove' ; repositories:string[]} | {op:'removeall'};
+    withdraw_guard?: {op:'add' | 'set'; guards:Service_Guard_Percent[]} 
+        | {op:'removeall'} | {op:'remove', addresses:string[]};
+    refund_guard?: {op:'add' | 'set'; guards:Service_Guard_Percent[]} 
+        | {op:'removeall'} | {op:'remove', addresses:string[]};
+    customer_required_info?: {pubkey:string; required_info:(string | BuyRequiredEnum)[]};
+    sales?: {op:'add', sales:Service_Sale[]} | {op:'remove'; sales_name:string[]}
+    order_new?: {buy_items:Service_Buy[], coin_object?:string, discount?:string, machine?:string, customer_info_crypto?: Customer_RequiredInfo, guard?:string | 'fetch'}
+    order_required_info?: {order:string; info:Customer_RequiredInfo};
+    order_refund?: {order:string; guard?:string;} | {order:string; arb:string; arb_token_type:string}; // guard address
+    order_withdrawl?: {order:string; data:WithdrawPayee}; // guard address
+    order_payer?: {order:string; payer_new: string}; // transfer the order payer permission to someaddress
+    order_agent?: {order:string; agents: string[]; progress?:string};
+    constructor(type_parameter:string, object: string | 'new' = 'new') { 
+        super(object) 
+        this.type_parameter = type_parameter;
+    }
+    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
+        if (!this.type_parameter) ERROR(Errors.InvalidParam, 'type_parameter');
+
+        var checkOwner = false; const guards : string[] = [];
+        const perms : PermissionIndexType[] = [];  var obj: ObjectService | undefined;
+
+        if (this?.permission && IsValidAddress(this.permission)) {
+            if (this?.object === 'new') {
+                perms.push(PermissionIndex.service)
+            }
+            if (this?.permission_new !== undefined) {
+                checkOwner = true;
+            }
+            if (this?.description !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.service_description)
+            }
+            if (this?.bPaused !== undefined) {
+                perms.push(PermissionIndex.service_pause)
+            }
+            if (this?.bPublished) { // publish is an irreversible one-time operation 
+                perms.push(PermissionIndex.service_publish)
+            }
+            if (this?.endpoint !== undefined) {
+                perms.push(PermissionIndex.service_endpoint)
+            }
+            if (this?.repository !== undefined) {
+                perms.push(PermissionIndex.service_repository)
+            }
+            if (this?.clone_new !== undefined) {
+                perms.push(PermissionIndex.service_clone)
+            }
+            if (this?.gen_discount !== undefined) {
+                perms.push(PermissionIndex.service_discount_transfer)
+            }
+            if (this?.arbitration !== undefined) {
+                perms.push(PermissionIndex.service_arbitration)
+            }
+            if (this?.buy_guard !== undefined) {
+                perms.push(PermissionIndex.service_buyer_guard)
+            }
+            if (this?.endpoint !== undefined) {
+                perms.push(PermissionIndex.service_endpoint)
+            }
+            if (this?.extern_withdraw_treasury !== undefined) {
+                perms.push(PermissionIndex.service_treasury)
+            }
+            if (this?.machine !== undefined) {
+                perms.push(PermissionIndex.service_machine)
+            }
+            if (this?.payee_treasury !== undefined && this.object !== 'new') {
+                perms.push(PermissionIndex.service_payee)
+            }
+            if (this?.withdraw_guard !== undefined) {
+                perms.push(PermissionIndex.service_withdraw_guards)
+            }
+            if (this?.refund_guard !== undefined) {
+                perms.push(PermissionIndex.service_refund_guards)
+            }
+            if (this?.customer_required_info !== undefined) {
+                perms.push(PermissionIndex.service_customer_required)
+            }
+            if (this?.sales !== undefined) {
+                perms.push(PermissionIndex.service_sales)
+            }
+            if (this?.order_new?.guard !== undefined) {
+                if (IsValidAddress(this.order_new.guard)) {
+                    guards.push(this.order_new.guard)
+                } else if (this?.object && IsValidAddress(this.object)) {
+                    if (!obj) {
+                        const r = await OBJECT_QUERY.objects({objects:[this.object], showContent:true});
+                        if (r?.objects && r.objects[0].type === 'Service') {
+                            obj = r.objects[0] as ObjectService;
+                        }                        
+                    }
+                    if (obj?.buy_guard) {
+                        guards.push(obj?.buy_guard)
+                    }
+                }
+            }
+            if (IsValidAddress((this?.order_refund as any)?.guard)) {
+                guards.push((this?.order_refund as any)?.guard)
+            }
+            if (this.order_withdrawl !== undefined) { // permission(may be guard) + withdraw_guard
+                perms.push(PermissionIndex.service_withdraw)
+            }
+
+            if (typeof(this?.order_withdrawl?.data?.withdraw_guard) === 'string' && IsValidAddress(this?.order_withdrawl?.data?.withdraw_guard)) {
+                guards.push(this?.order_withdrawl?.data?.withdraw_guard)
+            }
+
+            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+        }
+        return this.exec(account);
+    }
+    protected async operate (txb:TransactionBlock, passport?:PassportObject) {
+        let obj : Service | undefined ; let permission: any;  let payee: any;
+        if (this.object === 'new' && this?.type_parameter) {
+            if (!this?.permission || !IsValidAddress(this?.permission)) {
+                permission = Permission.New(txb, '');
+            }
+            if (!this?.payee_treasury || !IsValidAddress(this?.payee_treasury)) {
+                payee = Treasury.New(txb, this?.type_parameter, permission ?? this?.permission, '', permission?undefined:passport);
+            }
+            obj = Service.New(txb, this.type_parameter, permission??this?.permission, this?.description??'', payee??this?.payee_treasury, permission?undefined:passport)
+        } else {
+            if (IsValidAddress(this.object) && this.type_parameter && this.permission && IsValidAddress(this?.permission)) {
+                obj = Service.From(txb, this.type_parameter, this.permission, this.object)
+            }
+        }
+
+        if (obj) {
+            if (this?.description !== undefined && this.object !== 'new') {
+                obj?.set_description(this.description, passport);
+            }
+            if (this?.payee_treasury !== undefined && this.object !== 'new') {
+                obj?.set_payee(this.payee_treasury, passport);
+            }
+            if (this?.endpoint !== undefined) {
+                obj?.set_endpoint(this.endpoint, passport)
+            }
+            if (this?.buy_guard !== undefined) {
+                obj?.set_buy_guard(this.buy_guard, passport)
+            }
+            if (this?.bPaused !== undefined) {
+                obj?.pause(this.bPaused, passport)
+            }
+            if (this?.bPublished) {
+                obj?.publish(passport)
+            }
+            if (this?.clone_new !== undefined) {
+                obj?.clone(this.clone_new?.token_type_new, true, passport)
+            }
+            if (this?.machine !== undefined) {
+                obj?.set_machine(this.machine, passport)
+            }
+            if (this?.repository !== undefined) {
+                switch (this.repository.op) {
+                    case 'add':
+                        this.repository.repositories.forEach(v => obj?.add_repository(v, passport))
+                        break;
+                    case 'remove':
+                        obj?.remove_repository(this.repository.repositories, false, passport)
+                        break;
+                    case 'set':
+                        obj?.remove_repository([], true, passport)
+                        this.repository.repositories.forEach(v => obj?.add_repository(v, passport))
+                        break;
+                    case 'removeall':
+                        obj?.remove_repository([], true, passport)
+                        break;
+                }
+            }
+            if (this?.extern_withdraw_treasury !== undefined) {
+                switch(this.extern_withdraw_treasury.op) {
+                    case 'add':
+                        this.extern_withdraw_treasury.treasuries.forEach(v=>obj?.add_treasury(v.token_type, v.address, passport))
+                        break;
+                    case 'set':
+                        obj?.remove_treasury([], true, passport)
+                        this.extern_withdraw_treasury.treasuries.forEach(v=>obj?.add_treasury(v.token_type, v.address, passport))
+                        break;
+                    case 'remove':
+                        obj?.remove_treasury(this.extern_withdraw_treasury.addresses, false, passport)
+                        break;
+                    case 'removeall':
+                        obj?.remove_treasury([], false, passport)
+                        break;
+                }
+            }
+            if (this?.arbitration !== undefined) {
+                switch(this.arbitration.op) {
+                    case 'add':
+                        this.arbitration.arbitrations.forEach(v=>obj?.add_arbitration(v.address, v.token_type, passport))
+                        break;
+                    case 'set':
+                        obj?.remove_arbitration([], true, passport)
+                        this.arbitration.arbitrations.forEach(v=>obj?.add_arbitration(v.address, v.token_type, passport))
+                        break;
+                    case 'remove':
+                        obj?.remove_arbitration(this.arbitration.addresses, false, passport)
+                        break;
+                    case 'removeall':
+                        obj?.remove_arbitration([], false, passport)
+                        break;
+                }
+            }
+            if (this?.customer_required_info !== undefined) {
+                if (this.customer_required_info.required_info && this.customer_required_info.pubkey) {
+                    obj?.set_customer_required(this.customer_required_info.pubkey, this.customer_required_info.required_info, passport);
+                } else if (this.customer_required_info.pubkey) {
+                    obj?.change_required_pubkey(this.customer_required_info.pubkey, passport);
+                }
+            }
+            if (this?.refund_guard !== undefined) {
+                switch(this.refund_guard.op) {
+                    case 'add':
+                        obj?.add_refund_guards(this.refund_guard.guards, passport)
+                        break;
+                    case 'set':
+                        obj?.remove_refund_guards([], true, passport)
+                        obj?.add_refund_guards(this.refund_guard.guards, passport)
+                        break;
+                    case 'remove':
+                        obj?.remove_refund_guards(this.refund_guard.addresses, false, passport)
+                        break;
+                    case 'removeall':
+                        obj?.remove_refund_guards([], true, passport)
+                        break;
+                }
+            }
+            if (this?.gen_discount !== undefined) {
+                obj?.discount_transfer(this.gen_discount, passport)
+            }
+            if (this?.withdraw_guard !== undefined) {
+                switch(this.withdraw_guard.op) {
+                    case 'add':
+                        obj?.add_withdraw_guards(this.withdraw_guard.guards, passport)
+                        break;
+                    case 'set':
+                        obj?.remove_withdraw_guards([], true, passport)
+                        obj?.add_withdraw_guards(this.withdraw_guard.guards, passport)
+                        break;
+                    case 'remove':
+                        obj?.remove_withdraw_guards(this.withdraw_guard.addresses, false, passport)
+                        break;
+                    case 'removeall':
+                        obj?.remove_withdraw_guards([], true, passport)
+                        break;
+                }
+            }
+
+            if (this?.sales !== undefined) {
+                switch(this.sales.op) {
+                    case 'add':
+                        obj?.add_sales(this.sales.sales, false, passport)
+                        break;
+                    case 'remove':
+                        obj?.remove_sales(this.sales.sales_name, passport)
+                        break;
+                }
+            }
+            if (this?.order_new !== undefined) {
+                let b = BigInt(0); let coin : any;
+                this.order_new.buy_items.forEach(v => {
+                    b += BigInt(v.max_price) * BigInt(v.count)
+                })
+                if (b > BigInt(0)) {
+                    if (this?.type_parameter === '0x2::sui::SUI' || this?.type_parameter === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
+                        coin = txb.splitCoins(txb.gas, [b])[0];
+                    } else if (this?.order_new.coin_object) {
+                        coin = txb.splitCoins(this.order_new.coin_object, [b])[0];
+                    }                    
+                }
+
+                if (coin) {
+                    //@ crypto tools support
+                    obj?.buy(this.order_new.buy_items, coin, this.order_new.discount, this.order_new.machine, this.order_new.customer_info_crypto, passport)                    
+                }
+            }
+            if (this?.order_payer !== undefined && obj) {
+                obj?.change_order_payer(this?.order_payer.order, this.order_payer.payer_new)
+            }
+            if (this?.order_agent !== undefined) {
+                obj?.set_order_agent(this.order_agent.order, this.order_agent.agents, this.order_agent.progress)
+            }
+            if (this?.order_required_info !== undefined) {
+                obj?.update_order_required_info(this.order_required_info.order, this.order_required_info.info)
+            }
+            if (this?.order_refund !== undefined) {
+                if ((this?.order_refund as any)?.arb && (this?.order_refund as any)?.arb_token_type) {
+                    obj?.refund_withArb(this.order_refund.order, (this?.order_refund as any)?.arb, (this?.order_refund as any)?.arb_token_type)
+                } else {
+                    obj?.refund(this.order_refund.order, (this?.order_refund as any)?.guard, passport)
+                }
+            }
+            if (this?.order_withdrawl !== undefined && passport) { //@ need withdrawal passport
+                obj?.withdraw(this.order_withdrawl.order, this.order_withdrawl.data, passport)
+            }
+            if (this?.permission_new !== undefined) {
+                obj?.change_permission(this.permission_new);
+            }
+            if (permission) {
+                permission.launch();
+            }
+            if (payee) {
+                payee.launch();
+            }
+            if (this.object === 'new') {
+                obj?.launch();
+            }
+        }
+    }
+}