wowok_agent 0.1.13 → 0.1.16

package/src/account.ts

@@ -1,8 +1,8 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey, Protocol, CoinBalance, CoinStruct, TransactionResult, TransactionBlock, TransactionArgument, ERROR, Errors } from 'wowok';
+
+import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey, Protocol, TransactionBlock, ERROR, Errors,  } from 'wowok';
 import { getFaucetHost, requestSuiFromFaucetV0, requestSuiFromFaucetV1 } from 'wowok';
+import { type CoinBalance, type CoinStruct } from '@mysten/sui/client';
+import { type TransactionArgument, type TransactionResult } from '@mysten/sui/transactions';
 export interface AccountData {
     name: string; 
     default?: boolean;
@@ -49,12 +49,11 @@ export class Account {
                         }
                         data.push({name:name, key:key, default:bDefault})
                     }
-                } else {
-                    data = [{name:name, key:key, default:bDefault}];
+                    return data
                 }
-                return data     
             }
-        } catch(e) { console.log(e) }
+        } catch(e) {  /*console.log(e)*/  }
+        return [{name:name, key:key, default:bDefault}]     
     }
 
     private _default(buffer:string | null | undefined) : AccountData | undefined {
@@ -69,7 +68,7 @@ export class Account {
                     } 
                 }         
             }
-        } catch(e) { console.log(e) }
+        } catch(e) {  /*console.log(e)*/  }
     }
     private _get(buffer:string | null | undefined, name?:string, bNotFoundReturnDefault?:boolean) : AccountData | undefined {
         var data : AccountData[] | undefined;
@@ -86,7 +85,7 @@ export class Account {
                     }
                 }             
             }
-        } catch(e) { console.log(e) }
+        } catch(e) {  /*console.log(e)*/  }
     }
     private _rename(buffer:string | null | undefined, oldName:string, newName:string, bSwapIfExisted:boolean=true) : AccountData[] | undefined {
         var data : AccountData[] | undefined;
@@ -111,51 +110,55 @@ export class Account {
                     return data;
                 }
             } 
-        } catch(e) { console.log(e) }
+        } catch(e) {  /*console.log(e)*/  }
     }
     
     set_storage(storage: 'File' | 'Explorer' = 'File') {
         this.storage = storage
     }
 
-    gen(name:string, bDefault?: boolean) {       
+    async gen(name:string, bDefault?: boolean) {       
         try {
             if (this.storage === 'File') {
+                const [fs, os, path] = await Promise.all([import('fs'), import('os'), import('path')]);
                 const filePath = path.join(os.homedir(), Account_FileName);
                 fs.readFile(filePath, 'utf-8', (err, d) => {
                     const data = this._add(d, name, bDefault);
-                    fs.writeFileSync(filePath, JSON.stringify(data), 'utf-8')                    
+                    fs.writeFileSync(filePath, JSON.stringify(data), 'utf-8')                 
                 });
             } else if (this.storage === 'Explorer') {
                 const data = this._add(localStorage.getItem(Account_Key), name, bDefault);
                 localStorage.setItem(Account_Key, JSON.stringify(data))
             }            
-        } catch (e) { console.log(e) }
+        } catch (e) { /*console.log(e)*/ }
     }
-    default() : AccountData | undefined {
+    async default() : Promise<AccountData | undefined> {
         try {
             if (this.storage === 'File') {
+                const [fs, os, path] = await Promise.all([import('fs'), import('os'), import('path')]);
                 const filePath = path.join(os.homedir(), Account_FileName);
                 return this._default(fs.readFileSync(filePath, 'utf-8'));
             } else if (this.storage === 'Explorer') {
                 return this._default(localStorage.getItem(Account_Key));
             }            
-        } catch (e) { console.log(e) }
+        } catch (e) {  /*console.log(e)*/  }
     }
-    get(name?: string, bNotFoundReturnDefault:boolean=true) : AccountData | undefined {  
+    async get(name?: string, bNotFoundReturnDefault:boolean=true) : Promise<AccountData | undefined> {  
         try {
             if (this.storage === 'File') {
+                const [fs, os, path] = await Promise.all([import('fs'), import('os'), import('path')]);
                 const filePath = path.join(os.homedir(), Account_FileName);
                 return this._get(fs.readFileSync(filePath, 'utf-8'), name, bNotFoundReturnDefault);
             } else if (this.storage === 'Explorer') {
                 return this._get(localStorage.getItem(Account_Key), name, bNotFoundReturnDefault);
             }            
-        } catch (e) { console.log(e) }
+        } catch (e) {  /*console.log(e)*/  }
     }
-    rename(oldName:string, newName:string, bSwapIfExisted:boolean=true) : boolean {
+    async rename(oldName:string, newName:string, bSwapIfExisted:boolean=true) : Promise<boolean> {
         var res : AccountData[] | undefined;
         try {
             if (this.storage === 'File') {
+                const [fs, os, path] = await Promise.all([import('fs'), import('os'), import('path')]);
                 const filePath = path.join(os.homedir(), Account_FileName);
                 res = this._rename(fs.readFileSync(filePath, 'utf-8'), oldName, newName, bSwapIfExisted);
                 if (res) {fs.writeFileSync(filePath, JSON.stringify(res), 'utf-8') }
@@ -163,32 +166,33 @@ export class Account {
                 res = this._rename(localStorage.getItem(Account_Key), oldName, newName, bSwapIfExisted);
                 if (res) localStorage.setItem(Account_Key, JSON.stringify(res));
             }            
-        } catch (e) { console.log(e) }
+        } catch (e) { /*console.log(e)*/ }
         return res ? true : false
     }
 
-    get_address(name?:string, bNotFoundReturnDefault=true) : string | undefined {
-        const a = this.get(name, bNotFoundReturnDefault);
+    async get_address(name?:string, bNotFoundReturnDefault=true) : Promise<string | undefined> {
+        const a = await this.get(name, bNotFoundReturnDefault);
         if (a) {
             return Ed25519Keypair.fromSecretKey(fromHEX(a.key)).getPublicKey().toSuiAddress()
         }
     }
-    get_pubkey(name?:string, bNotFoundReturnDefault=true) : string | undefined {
-        const a = this.get(name, bNotFoundReturnDefault);
+    async get_pubkey(name?:string, bNotFoundReturnDefault=true) : Promise<string | undefined> {
+        const a = await this.get(name, bNotFoundReturnDefault);
         if (a) {
             return Ed25519Keypair.fromSecretKey(fromHEX(a.key)).getPublicKey().toSuiPublicKey()
         }
     }
-    get_pair(name?:string, bNotFoundReturnDefault=true) : Ed25519Keypair | undefined {
-        const a = this.get(name, bNotFoundReturnDefault);
+    async get_pair(name?:string, bNotFoundReturnDefault=true) : Promise<Ed25519Keypair | undefined> {
+        const a = await this.get(name, bNotFoundReturnDefault);
         if (a) {
             return Ed25519Keypair.fromSecretKey(fromHEX(a.key))
         }
     }
     
-    list() : AccountData_Show[] {
+    async list() : Promise<AccountData_Show[]> {
         try {
             if (this.storage === 'File') {
+                const [fs, os, path] = await Promise.all([import('fs'), import('os'), import('path')]);
                 const filePath = path.join(os.homedir(), Account_FileName);
                 const a = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as AccountData[];
                 return a.map(v => {
@@ -200,23 +204,22 @@ export class Account {
                     return {name:v.name, default:v?.default, address:Ed25519Keypair.fromSecretKey(fromHEX(v.key)).getPublicKey().toSuiAddress()}
                 })
             }            
-        } catch (e) { console.log(e) }
+        } catch (e) { /*console.log(e)*/ }
         return []
     }
     
-    faucet(name?:string) {
-        const address = this.get_address(name, true);
+    async faucet(name?:string) {
+        const address = await this.get_address(name, true);
         if (address) {
-            requestSuiFromFaucetV0({host:getFaucetHost('testnet'), recipient:address}).catch(e => {
-                console.log(e)
-                requestSuiFromFaucetV1({host:getFaucetHost('testnet'), recipient:address}).catch(e => console.log(e));
+            await requestSuiFromFaucetV0({host:getFaucetHost('testnet'), recipient:address}).catch(e => {
+                //console.log(e)
             })
         }
     }
 
     // token_type is 0x2::sui::SUI, if not specified.
     balance = async (name?:string, token_type?:string) : Promise<CoinBalance | undefined> => {
-        const addr = this.get_address(name);
+        const addr = await this.get_address(name);
         if (addr) {
             return await Protocol.Client().getBalance({owner: addr, coinType:token_type});
         }
@@ -224,14 +227,14 @@ export class Account {
 
     // token_type is 0x2::sui::SUI, if not specified.
     coin = async (name?:string, token_type?:string) : Promise<CoinStruct[] | undefined> => {
-        const addr = this.get_address(name);
+        const addr = await this.get_address(name);
         if (addr) {
             return (await Protocol.Client().getCoins({owner: addr, coinType:token_type})).data;
         }
     }
 
     get_coin_object = async (txb: TransactionBlock, balance_required:string | bigint | number, name?:string, token_type?:string) : Promise<TransactionResult | undefined> => {
-        const addr = this.get_address(name);
+        const addr = await this.get_address(name);
         const b = BigInt(balance_required);
 
         if (addr && b > BigInt(0)) {
@@ -259,7 +262,7 @@ export class Account {
         }
     }
     coin_with_balance = async(balance_required:string | bigint | number, account?:string, token_type?:string) : Promise<string | undefined> => {
-        const pair = this.get_pair(account, true);
+        const pair = await this.get_pair(account, true);
         if (!pair) ERROR(Errors.Fail, 'account invalid')
     
         const txb = new TransactionBlock();

package/src/call/arbitration.ts

@@ -1,9 +1,12 @@
 import { TransactionBlock, IsValidArgType, PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, 
-    PermissionIndexType, Treasury, Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, 
+    PermissionIndexType, Treasury, Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee,
+    ArbObject, 
 } from 'wowok';
 import { query_objects, ObjectArbitration, } from '../objects';
 import { CallBase, CallResult, Namedbject} from "./base";
+export { BCS, getSuiMoveConfig, } from '@mysten/bcs';
 
+/// The execution priority is determined by the order in which the object attributes are arranged
 export interface CallArbitration_Data {
     type_parameter: string;
     object?: {address:string} | {namedNew: Namedbject}; // undefined or {named_new...} for creating a new object
@@ -13,9 +16,9 @@ export interface CallArbitration_Data {
     fee?: string;
     fee_treasury?: {address:string} | {namedNew: Namedbject, description?:string}; 
     arb_new?: {data: Dispute; guard?:string | 'fetch'; namedNew?: Namedbject}; // dispute an order, and a new Arb launched.
-    arb_withdraw_fee?: {arb:string; data:WithdrawFee};
-    arb_vote?: Vote;
-    arb_arbitration?: Feedback;
+    arb_withdraw_fee?: {arb?:string; data:WithdrawFee};
+    arb_vote?: {arb?: string; voting_guard?: string; agrees: number[]};
+    arb_arbitration?: {arb?:string; feedback:string; indemnity?:string};
     usage_guard?: string;
     voting_guard?: {op:'add' | 'set'; data:VotingGuard[]} | {op:'remove', guards:string[]} | {op:'removeall'};
     bPaused?: boolean;
@@ -127,52 +130,71 @@ export class CallArbitration extends CallBase {
         }
 
         if (obj) {
+            const pst = permission?undefined:passport;
             if (this.data?.description !== undefined && object_address) {
-                obj?.set_description(this.data.description, passport);
+                obj?.set_description(this.data.description, pst);
             }
             if (this.data?.endpoint !== undefined) {
-                obj?.set_endpoint(this.data.endpoint, passport)
+                obj?.set_endpoint(this.data.endpoint, pst)
             }
             if (this.data?.fee !== undefined && object_address) {
-                obj?.set_fee(BigInt(this.data.fee), passport)
+                obj?.set_fee(BigInt(this.data.fee), pst)
             }
             if (treasury_address !== undefined && object_address) {
-                obj?.set_withdrawTreasury(treasury_address, passport)
+                obj?.set_withdrawTreasury(treasury_address, pst)
             }
+            var arb_new : ArbObject | undefined;
             if (this.data?.arb_new !== undefined) {
-                await this.new_with_mark(txb, obj?.dispute(this.data.arb_new.data, passport), (this.data?.arb_new as any)?.namedNew, account);
+                arb_new = obj?.arb(this.data.arb_new.data, pst);
             }
+
             if (this.data?.arb_arbitration !== undefined) {
-                obj?.arbitration(this.data.arb_arbitration, passport)
+                const a = this.data.arb_arbitration.arb ?? arb_new;
+                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_arbitration');
+
+                obj?.arbitration({arb:a!, feedback:this.data.arb_arbitration.feedback, indemnity:this.data.arb_arbitration.indemnity}, pst)
             }
+
             if (this.data?.arb_vote !== undefined) {
-                obj?.vote(this.data.arb_vote, passport)
+                const a = this.data.arb_vote.arb ?? arb_new;
+                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_vote');
+
+                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) {
-                obj?.withdraw_fee(this.data.arb_withdraw_fee.arb, this.data.arb_withdraw_fee.data, passport)
+                const a = this.data.arb_withdraw_fee.arb ?? arb_new;
+                if (!a) ERROR(Errors.Fail, 'arb invalid: arb_withdraw_fee');
+
+                obj?.withdraw_fee(a!, this.data.arb_withdraw_fee.data, pst)
+            }
+
+            if (arb_new) {
+                await this.new_with_mark(txb, obj?.arb_launch(arb_new), (this.data?.arb_new as any)?.namedNew, account);
             }
+            
             if (this.data?.voting_guard !== undefined) {
                 switch (this.data.voting_guard.op) {
                     case 'add':
-                        obj?.add_voting_guard(this.data.voting_guard.data, passport)
+                        obj?.add_voting_guard(this.data.voting_guard.data, pst)
                         break;
                     case 'remove':
-                        obj?.remove_voting_guard(this.data.voting_guard.guards, false, passport)
+                        obj?.remove_voting_guard(this.data.voting_guard.guards, false, pst)
                         break;
                     case 'set':
-                        obj?.remove_voting_guard([], true, passport)
-                        obj?.add_voting_guard(this.data.voting_guard.data, passport)
+                        obj?.remove_voting_guard([], true, pst)
+                        obj?.add_voting_guard(this.data.voting_guard.data, pst)
                         break;
                     case 'removeall':
-                        obj?.remove_voting_guard([], true, passport)
+                        obj?.remove_voting_guard([], true, pst)
                         break;
                 }
             }
             if (this.data.usage_guard !== undefined) {
-                obj?.set_guard(this.data.usage_guard, passport)
+                obj?.set_guard(this.data.usage_guard, pst)
             }
             if (this.data?.bPaused !== undefined) {
-                obj?.pause(this.data.bPaused, passport);
+                obj?.pause(this.data.bPaused, pst);
             }
             if (withdraw_treasury) {
                 await this.new_with_mark(txb, withdraw_treasury.launch(), (this.data?.fee_treasury as any)?.namedNew, account);

package/src/call/base.ts

@@ -1,12 +1,14 @@
 
 
-import { Protocol, TransactionBlock, CallResponse, Guard, TransactionArgument, Entity, IsValidAddress, Resource, TxbObject, TransactionResult, TxbAddress, array_unique, TagName, ResourceObject} from 'wowok';
-import { PassportObject, Errors, ERROR, Permission, 
+import { Protocol, Entity, Resource, TxbAddress, array_unique, TagName, ResourceObject, PassportObject, Errors, ERROR, Permission, 
     PermissionIndexType, GuardParser, Passport, WitnessFill
 } from 'wowok';
 import { query_permission } from '../permission';
 import { Account } from '../account';
 import { ObjectBase, queryTableItem_Personal, raw2type} from '../objects';
+import { Transaction as TransactionBlock} from '@mysten/sui/transactions';
+import { type SuiTransactionBlockResponse as CallResponse} from '@mysten/sui/client'; 
+
 
 export interface Namedbject {
     name?: string;
@@ -26,10 +28,6 @@ export interface GuardInfo_forCall {
     witness: WitnessFill[];
 }
 
-export interface CallWithWitnessParam {
-    info: GuardInfo_forCall;
-    account?:string;
-}
 export type CallResult = GuardInfo_forCall | CallResponse | undefined;
 
 
@@ -56,22 +54,22 @@ export class CallBase {
     // return ResponseData when the call has completed; 
     // throw an exception when errors.
     async call(account?:string) : Promise<CallResult>  { return undefined };
-    async call_with_witness (param: CallWithWitnessParam) : Promise<CallResponse | undefined> {
-        if (param.info.guard.length > 0) {         // prepare passport
-            const p: GuardParser | undefined = await GuardParser.Create([...param.info.guard]);
+    async call_with_witness (info: GuardInfo_forCall, account?:string) : Promise<CallResponse | undefined> {
+        if (info.guard.length > 0) {         // prepare passport
+            const p: GuardParser | undefined = await GuardParser.Create([...info.guard]);
 
             if (p) {
-                const query = await p.done(param.info.witness);
+                const query = await p.done(info.witness);
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
-                    await this.operate(new TransactionBlock(), passport?.get_object(), param?.account)
+                    await this.operate(new TransactionBlock(), passport?.get_object(), account)
                     passport.destroy();
                     
-                    return await this.sign_and_commit(txb, param.account);
+                    return await this.sign_and_commit(txb, account);
                 }
             } else {
-                ERROR(Errors.Fail, 'guard finish_passport')
+                ERROR(Errors.Fail, 'guard verify')
             }
         } 
     }
@@ -81,7 +79,7 @@ export class CallBase {
         var guards : string[] = [];
 
         if (permIndex.length > 0 || checkOwner) {
-            const addr = Account.Instance().get_address(account);
+            const addr = await Account.Instance().get_address(account);
             if (!addr) ERROR(Errors.InvalidParam, 'check_permission_and_call: account invalid');
 
             const p = await query_permission({permission_object:permission, address:addr!});
@@ -131,7 +129,7 @@ export class CallBase {
         const tags = named_new?.tags ? array_unique([...named_new.tags, ...innerTags]) : array_unique([...innerTags]);
 
         if (!this.resouceObject) {
-            const addr = Account.Instance().get_address(account);
+            const addr = await Account.Instance().get_address(account);
             if (addr) {
                 const r = await queryTableItem_Personal({address:addr}); //@ use cache
                 if (!r?.mark_object) {
@@ -149,7 +147,7 @@ export class CallBase {
     }
 
     protected async sign_and_commit(txb: TransactionBlock, account?: string) : Promise<CallResponse> {
-        const pair = Account.Instance().get_pair(account, true);
+        const pair = await Account.Instance().get_pair(account, true);
         if (!pair) ERROR(Errors.Fail, 'account invalid')
         
         if (this.resouceObject) {

package/src/call/demand.ts

@@ -103,12 +103,13 @@ export class CallDemand extends CallBase {
         }
 
         if (obj) {
+            const pst = permission?undefined:passport;
             if (this.data?.description !== undefined && object_address) {
-                obj?.set_description(this.data.description, passport);
+                obj?.set_description(this.data.description, pst);
             }
             if (this.data?.time_expire !== undefined && object_address) {
                 obj?.expand_time(this.data.time_expire.op === 'duration' ? true : false, 
-                    this.data.time_expire.op === 'duration' ? this.data.time_expire.minutes : this.data.time_expire.time, passport)
+                    this.data.time_expire.op === 'duration' ? this.data.time_expire.minutes : this.data.time_expire.time, pst)
             }
             if (this.data?.bounty !== undefined) {
                 if (this.data.bounty.op === 'add') {
@@ -122,17 +123,17 @@ export class CallDemand extends CallBase {
                         if (r) obj.deposit(r)
                     }
                 } else if (this.data.bounty.op === 'reward') {
-                    obj?.yes(this.data.bounty.service, passport);
+                    obj?.yes(this.data.bounty.service, pst);
                 } else if (this.data.bounty.op === 'refund') {
-                    obj?.refund(passport);
+                    obj?.refund(pst);
                 } 
             }
             if (this.data?.present !== undefined) {
-                //@ demand guard and its passport, if set
-                obj?.present(this.data.present.service, this.data.present.service_pay_type, this.data.present.recommend_words, passport);
+                //@ demand guard and its pst, if set
+                obj?.present(this.data.present.service, this.data.present.service_pay_type, this.data.present.recommend_words, pst);
             }
             if (this.data?.guard !== undefined) {
-                obj?.set_guard(this.data.guard.address, this.data.guard?.service_id_in_guard ?? undefined, passport)
+                obj?.set_guard(this.data.guard.address, this.data.guard?.service_id_in_guard ?? undefined, pst)
             }
             if (permission) {
                 await this.new_with_mark(txb, permission.launch(), (this.data?.permission as any)?.namedNew, account);

package/src/call/guard.ts

@@ -4,7 +4,7 @@
  */
 
 import { Bcs, ContextType, ERROR, Errors, IsValidU8, OperatorType, ValueType, GUARD_QUERIES, IsValidAddress, 
-    concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead, CallResponse, 
+    concatenate, TransactionBlock, Protocol, FnCallType, hasDuplicates, insertAtHead,
     IsValidDesription, PassportObject,
     IsValidGuardIdentifier} from "wowok";
 import { CallBase, CallResult, Namedbject } from "./base";
@@ -22,8 +22,7 @@ export type GuardNode = { identifier: number; } // Data from GuardConst
     | {logic: OperatorType.TYPE_LOGIC_AS_U256_GREATER | OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL
         | OperatorType.TYPE_LOGIC_AS_U256_LESSER | OperatorType.TYPE_LOGIC_AS_U256_LESSER_EQUAL 
         | OperatorType.TYPE_LOGIC_AS_U256_EQUAL | OperatorType.TYPE_LOGIC_EQUAL | OperatorType.TYPE_LOGIC_HAS_SUBSTRING 
-        | OperatorType.TYPE_LOGIC_ALWAYS_TRUE | OperatorType.TYPE_LOGIC_NOT 
-        | OperatorType.TYPE_LOGIC_AND | OperatorType.TYPE_LOGIC_OR;  parameters: GuardNode[];}
+        | OperatorType.TYPE_LOGIC_NOT | OperatorType.TYPE_LOGIC_AND | OperatorType.TYPE_LOGIC_OR;  parameters: GuardNode[];}
     | {calc: OperatorType.TYPE_NUMBER_ADD | OperatorType.TYPE_NUMBER_DEVIDE | OperatorType.TYPE_NUMBER_MOD 
         | OperatorType.TYPE_NUMBER_MULTIPLY | OperatorType.TYPE_NUMBER_SUBTRACT; parameters: GuardNode[];}
     | {value_type: ValueType; value:any; } // Data 
@@ -149,10 +148,6 @@ const buildNode = (guard_node:GuardNode, type_required:ValueType | 'number' | 'v
     } else if (node?.logic !== undefined) {
         checkType(ValueType.TYPE_BOOL, type_required, node); // bool
         switch (node?.logic) {
-            case OperatorType.TYPE_LOGIC_ALWAYS_TRUE:
-                if (node.parameters.length !== 0) ERROR(Errors.InvalidParam, 'node logic parameters length must be 0'+ JSON.stringify(node));
-                output.push(Bcs.getInstance().ser(ValueType.TYPE_U8, node.logic)); // TYPE 
-                break;
             case OperatorType.TYPE_LOGIC_AND:
             case OperatorType.TYPE_LOGIC_OR:
                 if (node.parameters.length < 2) ERROR(Errors.InvalidParam, 'node logic parameters length must >= 2'+ JSON.stringify(node));