wowok_agent 0.0.1 → 0.1.3

package/README.md

@@ -16,8 +16,8 @@ $ npm i wowok_agent@latest
 The protocol address may change due to protocol upgrade. Please update the SDK to the latest version.
 
 ### Fetures 
-##### Operation account generation and management.
-##### Integrate queries and operations.
-##### Simplifies and supports JSON-driven operations.
+- *Operation account generation and management.*
+- *Integrate queries and operations.*
+- *Simplifies and supports JSON-driven operations.*
 
   

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok_agent",
-  "version": "0.0.1",
+  "version": "0.1.3",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/account.ts

@@ -2,13 +2,19 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey } from 'wowok';
-
+import { getFaucetHost, requestSuiFromFaucetV0, requestSuiFromFaucetV1 } from 'wowok';
 export interface AccountData {
     name: string; 
     default?: boolean;
     key: string;
 }
 
+export interface AccountData_Show {
+    name: string;
+    default?: boolean;
+    address: string;
+}
+
 const Account_FileName = 'wowok.dat';
 const Account_Key = 'wowok-data-v1';
 
@@ -184,15 +190,31 @@ export class Account {
         }
     }
     
-    list() : AccountData[] {
+    list() : AccountData_Show[] {
         try {
             if (this.storage === 'File') {
                 const filePath = path.join(os.homedir(), Account_FileName);
-                return JSON.parse(fs.readFileSync(filePath, 'utf-8')) as AccountData[]
+                const a = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as AccountData[];
+                return a.map(v => {
+                    return {name:v.name, default:v?.default, address:Ed25519Keypair.fromSecretKey(fromHEX(v.key)).getPublicKey().toSuiAddress()}
+                })
             } else if (this.storage === 'Explorer') {
-                return JSON.parse(localStorage.getItem(Account_Key) ?? '') as AccountData[];
+                const a = JSON.parse(localStorage.getItem(Account_Key) ?? '') as AccountData[];
+                return a.map(v => {
+                    return {name:v.name, default:v?.default, address:Ed25519Keypair.fromSecretKey(fromHEX(v.key)).getPublicKey().toSuiAddress()}
+                })
             }            
         } catch (e) { console.log(e) }
         return []
     }
+    
+    faucet(name?:string) {
+        const address = 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));
+            })
+        }
+    }
 }

package/src/call/arbitration.ts

@@ -1,12 +1,14 @@
-import { TransactionBlock, CallResponse} from 'wowok';
+import { TransactionBlock, CallResponse, IsValidArgType} from 'wowok';
 import { PassportObject, IsValidAddress, Errors, ERROR, Permission, PermissionIndex, PermissionIndexType, Treasury, 
     Arbitration, Dispute, Feedback, Vote, VotingGuard, WithdrawFee, WitnessFill
 } from 'wowok';
-import { OBJECT_QUERY, ObjectArbitration, } from '../objects';
-import { CallBase } from "./call";
+import { query_objects, ObjectArbitration, } from '../objects';
+import { CallBase, CallResult } from "./base";
 
-export class CallArbitration extends CallBase {
-    type_parameter: string;
+export interface CallArbitration_Data {
+    object?: string; // undefined for creating a new object
+    permission?: string; 
+    type_parameter?: string;
     permission_new?: string;
     description?: string;
     bPaused?: boolean;
@@ -19,120 +21,133 @@ export class CallArbitration extends CallBase {
     arb_withdraw_fee?: {arb:string; data:WithdrawFee};
     arb_vote?: Vote;
     arb_arbitration?: Feedback;
-    constructor(type_parameter:string, object: string | 'new' = 'new') { 
-        super(object) 
-        this.type_parameter = type_parameter;
+}
+export class CallArbitration extends CallBase {
+    data: CallArbitration_Data;
+    constructor (data: CallArbitration_Data) {
+        super();
+        this.data  = data;
     }
-    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>   {
-        if (!this.type_parameter) ERROR(Errors.InvalidParam, 'type_parameter')
+
+    async call(account?:string) : Promise<CallResult> {
+        if (!this.data?.type_parameter || !IsValidArgType(this.data.type_parameter)) {
+            ERROR(Errors.IsValidArgType, 'arbitration.type_parameter')
+        }
 
         var checkOwner = false; const guards : string[] = [];
         const perms : PermissionIndexType[] = [];  var obj: ObjectArbitration | undefined ;
 
-        if (this?.permission && IsValidAddress(this.permission)) {
-            if (this?.object === 'new') {
+        if (this.data?.permission && IsValidAddress(this.data.permission)) {
+            if (!this.data?.object) {
                 perms.push(PermissionIndex.arbitration)
             }
-            if (this?.permission_new !== undefined) {
+            if (this.data?.permission_new !== undefined) {
                 checkOwner = true;
             }
-            if (this?.description !== undefined && this.object !== 'new') {
+            if (this.data?.description !== undefined && this.data.object) {
                 perms.push(PermissionIndex.arbitration_description)
             }
-            if (this?.bPaused !== undefined) {
+            if (this.data?.bPaused !== undefined) {
                 perms.push(PermissionIndex.arbitration_pause)
             }
-            if (this?.endpoint == undefined) { // publish is an irreversible one-time operation 
+            if (this.data?.endpoint == undefined) { // publish is an irreversible one-time operation 
                 perms.push(PermissionIndex.arbitration_endpoint)
             }
-            if (this?.fee !== undefined && this.object !== 'new') {
+            if (this.data?.fee !== undefined && this.data.object) {
                 perms.push(PermissionIndex.arbitration_fee)
             }
-            if (this?.fee_treasury !== undefined && this.object !== 'new') {
+            if (this.data?.fee_treasury !== undefined && this.data.object) {
                 perms.push(PermissionIndex.arbitration_treasury)
             }
-            if (this?.usage_guard !== undefined) {
+            if (this.data?.usage_guard !== undefined) {
                 perms.push(PermissionIndex.arbitration_guard)
             }
-            if (this?.voting_guard !== undefined) {
+            if (this.data?.voting_guard !== undefined) {
                 perms.push(PermissionIndex.arbitration_voting_guard)
             }
-            if (this?.arb_arbitration !== undefined) {
+            if (this.data?.arb_arbitration !== undefined) {
                 perms.push(PermissionIndex.arbitration_arbitration)
             }
-            if (this?.arb_new?.guard !== undefined) {
-                if (IsValidAddress(this.arb_new.guard)) {
-                    guards.push(this.arb_new.guard)
+            if (this.data?.arb_new?.guard !== undefined) {
+                if (IsValidAddress(this.data.arb_new.guard)) {
+                    guards.push(this.data.arb_new.guard)
                 } else {
-                    if (!obj) {
-                        const r = await OBJECT_QUERY.objects({objects:[this.object], showContent:true});
-                        if (r?.objects && r.objects[0].type === 'Treasury') {
-                            obj = r.objects[0] as ObjectArbitration;
+                    if (!this.data.object) { // new
+                        if (this.data?.usage_guard && IsValidAddress(this.data?.usage_guard)) {
+                            guards.push(this.data.usage_guard)
                         }
-                    }
-                    if (obj?.usage_guard) {
-                        guards.push(obj?.usage_guard)
+                    } else {
+                        if (!obj) {
+                            const r = await query_objects({objects:[this.data.object!], showContent:true});
+                            if (r?.objects && r.objects[0].type === 'Arbitration') {
+                                obj = r.objects[0] as ObjectArbitration;
+                            }                                
+                        }
+ 
+                        if (obj?.usage_guard) {
+                            guards.push(obj.usage_guard)
+                        }                   
                     }
                 }
             }
-            if (this?.arb_vote !== undefined) {
+            if (this.data?.arb_vote !== undefined) {
                 perms.push(PermissionIndex.treasury_receive)
             }
-            if (typeof(this?.arb_vote?.voting_guard) === 'string' && IsValidAddress(this?.arb_vote?.voting_guard)) {
-                guards.push(this?.arb_vote?.voting_guard)
+            if (typeof(this.data?.arb_vote?.voting_guard) === 'string' && IsValidAddress(this.data?.arb_vote?.voting_guard)) {
+                guards.push(this.data?.arb_vote?.voting_guard)
             }
 
-            return await this.check_permission_and_call(this.permission, perms, guards, checkOwner, undefined, account)
+            return await this.check_permission_and_call(this.data.permission, perms, guards, checkOwner, undefined, account)
         }
         return this.exec(account);
     }
     protected async operate(txb:TransactionBlock, passport?:PassportObject) {
         let obj : Arbitration | undefined ; let permission: any; let withdraw_treasury:any;
-        if (this.object === 'new' && this?.type_parameter) {
-            if (!this?.permission || !IsValidAddress(this?.permission)) {
+        if (!this.data.object) {
+            if (!this.data?.permission || !IsValidAddress(this.data?.permission)) {
                 permission = Permission.New(txb, '');
             }
-            if (!this?.fee_treasury || !IsValidAddress(this?.fee_treasury)) {
-                withdraw_treasury = Treasury.New(txb, this?.type_parameter, permission ?? this?.permission, '', permission?undefined:passport);
+            if (!this.data?.fee_treasury || !IsValidAddress(this.data?.fee_treasury)) {
+                withdraw_treasury = Treasury.New(txb, this.data?.type_parameter!, permission ?? this.data?.permission, '', permission?undefined:passport);
             }
-            obj = Arbitration.New(txb, this.type_parameter, permission ?? this?.permission, this?.description??'', 
-                BigInt(this?.fee ?? 0), withdraw_treasury??this.fee_treasury, permission?undefined:passport);
-        } else {
-            if (IsValidAddress(this.object) && this.type_parameter && this.permission && IsValidAddress(this?.permission)) {
-                obj = Arbitration.From(txb, this.type_parameter, this.permission, this.object)
+            obj = Arbitration.New(txb, this.data.type_parameter!, permission ?? this.data?.permission, this.data?.description??'', 
+                BigInt(this.data?.fee ?? 0), withdraw_treasury??this.data.fee_treasury, permission?undefined:passport);
+        } else if (this.data.object) {
+            if (IsValidAddress(this.data.object) && this.data.type_parameter && this.data.permission && IsValidAddress(this.data?.permission)) {
+                obj = Arbitration.From(txb, this.data.type_parameter, this.data.permission, this.data.object)
             }
         }
 
         if (obj) {
-            if (this?.description !== undefined && this.object !== 'new') {
-                obj?.set_description(this.description, passport);
+            if (this.data?.description !== undefined && this.data.object) {
+                obj?.set_description(this.data.description, passport);
             }
-            if (this?.bPaused !== undefined) {
-                obj?.pause(this.bPaused, passport);
+            if (this.data?.bPaused !== undefined) {
+                obj?.pause(this.data.bPaused, passport);
             }
-            if (this?.endpoint !== undefined) {
-                obj?.set_endpoint(this.endpoint, passport)
+            if (this.data?.endpoint !== undefined) {
+                obj?.set_endpoint(this.data.endpoint, passport)
             }
-            if (this?.fee !== undefined && this.object !== 'new') {
-                obj?.set_fee(BigInt(this.fee), passport)
+            if (this.data?.fee !== undefined && this.data.object) {
+                obj?.set_fee(BigInt(this.data.fee), passport)
             }
-            if (this.fee_treasury !== undefined && this.object !== 'new') {
-                obj?.set_withdrawTreasury(this.fee_treasury, passport)
+            if (this.data.fee_treasury !== undefined && this.data.object) {
+                obj?.set_withdrawTreasury(this.data.fee_treasury, passport)
             }
-            if (this.usage_guard !== undefined) {
-                obj?.set_guard(this.usage_guard, passport)
+            if (this.data.usage_guard !== undefined) {
+                obj?.set_guard(this.data.usage_guard, passport)
             }
-            if (this?.voting_guard !== undefined) {
-                switch (this.voting_guard.op) {
+            if (this.data?.voting_guard !== undefined) {
+                switch (this.data.voting_guard.op) {
                     case 'add':
-                        obj?.add_voting_guard(this.voting_guard.data, passport)
+                        obj?.add_voting_guard(this.data.voting_guard.data, passport)
                         break;
                     case 'remove':
-                        obj?.remove_voting_guard(this.voting_guard.guards, false, passport)
+                        obj?.remove_voting_guard(this.data.voting_guard.guards, false, passport)
                         break;
                     case 'set':
                         obj?.remove_voting_guard([], true, passport)
-                        obj?.add_voting_guard(this.voting_guard.data, passport)
+                        obj?.add_voting_guard(this.data.voting_guard.data, passport)
                         break;
                     case 'removeall':
                         obj?.remove_voting_guard([], true, passport)
@@ -140,20 +155,20 @@ export class CallArbitration extends CallBase {
                 }
             }
             
-            if (this?.arb_new !== undefined) {
-                obj?.dispute(this.arb_new.data, passport)
+            if (this.data?.arb_new !== undefined) {
+                obj?.dispute(this.data.arb_new.data, passport)
             }
-            if (this?.arb_arbitration !== undefined) {
-                obj?.arbitration(this.arb_arbitration, passport)
+            if (this.data?.arb_arbitration !== undefined) {
+                obj?.arbitration(this.data.arb_arbitration, passport)
             }
-            if (this?.arb_vote !== undefined) {
-                obj?.vote(this.arb_vote, passport)
+            if (this.data?.arb_vote !== undefined) {
+                obj?.vote(this.data.arb_vote, passport)
             }
-            if (this?.arb_withdraw_fee !== undefined) {
-                obj?.withdraw_fee(this.arb_withdraw_fee.arb, this.arb_withdraw_fee.data, passport)
+            if (this.data?.arb_withdraw_fee !== undefined) {
+                obj?.withdraw_fee(this.data.arb_withdraw_fee.arb, this.data.arb_withdraw_fee.data, passport)
             }
-            if (this?.permission_new !== undefined) {
-                obj?.change_permission(this.permission_new);
+            if (this.data?.permission_new !== undefined) {
+                obj?.change_permission(this.data.permission_new);
             }
             if (withdraw_treasury) {
                 withdraw_treasury.launch();
@@ -161,7 +176,7 @@ export class CallArbitration extends CallBase {
             if (permission) {
                 permission.launch();
             }
-            if (this.object === 'new') {
+            if (!this.data.object) {
                 obj?.launch();
             }
         }

package/src/call/{call.ts → base.ts}

@@ -1,14 +1,10 @@
-/**
- * Provide a this interface for AI
- * Operation sequence Priority: common operation > Guard change > permission change
- * Recommended: Changes to guard and permission are committed on-chain separately to avoid permission dependencies for other operations.
- */
 
-import { Protocol, TransactionBlock, CallResponse} from 'wowok';
+
+import { Protocol, TransactionBlock, CallResponse, Guard} from 'wowok';
 import { PassportObject, Errors, ERROR, Permission, 
     PermissionIndexType, GuardParser, Passport, WitnessFill
 } from 'wowok';
-import { PERMISSION_QUERY } from '../permission';
+import { query_permission } from '../permission';
 import { Account } from '../account';
 import { ObjectBase } from '../objects';
 
@@ -17,27 +13,46 @@ export interface ResponseData extends ObjectBase {
     change:'created' | 'mutated' | string;
 } 
 
+export interface GuardInfo_forCall {
+    guard: string[];
+    witness: WitnessFill[];
+}
+
+export interface CallWithWitnessParam {
+    info: GuardInfo_forCall;
+    account?:string;
+}
+export type CallResult = GuardInfo_forCall | CallResponse | undefined;
+
+export function ResponseData(response: CallResponse | undefined ) : ResponseData[] {
+    const res : ResponseData[] = [];
+    response?.objectChanges?.forEach(v => {
+        const type_raw: string | undefined = (v as any)?.objectType;
+        const type:string | undefined = type_raw ? Protocol.Instance().object_name_from_type_repr(type_raw) : undefined;
+        if (type) {
+            res.push({type:type, type_raw:type_raw, object:(v as any)?.objectId, version:(v as any)?.version,
+                owner:(v as any)?.owner, change:v.type
+            })
+        }
+    })
+    return res;
+}
 export class CallBase {
-    object: string | 'new' ;
-    permission?: string;
-    constructor(object: string | 'new' = 'new') {
-        this.object = object;
-    }
     // operation implementation for a call
     protected async operate(txb:TransactionBlock, passport?:PassportObject) {};
-    
+    constructor () {}
     // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call; 
     // return ResponseData when the call has completed; 
     // throw an exception when errors.
-    async call(account?:string) : Promise<WitnessFill[] | CallResponse | undefined>  { return undefined };
-    async call_with_witness (guards: string[], fill?: WitnessFill[], account?:string) : Promise<CallResponse | undefined> {
-        if (guards.length > 0) {         // prepare passport
-            const p: GuardParser | undefined = await GuardParser.Create([...guards]);
-            const pair = Account.Instance().get_pair(account, true);
+    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]);
+            const pair = Account.Instance().get_pair(param.account, true);
             if (!pair) ERROR(Errors.Fail, 'account invalid')
 
             if (p) {
-                const query = await p.done(fill);
+                const query = await p.done(param.info.witness);
                 if (query) {
                     const txb = new TransactionBlock();
                     const passport = new Passport(txb, query!);   
@@ -57,13 +72,13 @@ export class CallBase {
     }
 
     protected async check_permission_and_call (permission:string, permIndex: PermissionIndexType[], guards_needed: string[],
-        checkOwner?:boolean, checkAdmin?:boolean, account?:string) : Promise<WitnessFill[] | CallResponse>  {
+        checkOwner?:boolean, checkAdmin?:boolean, account?:string) : Promise<CallResult>  {
         var guards : string[] = [];
         const pair = Account.Instance().get_pair(account, true);
         if (!pair) ERROR(Errors.Fail, 'account invalid')
 
         if (permIndex.length > 0 || checkOwner) {
-            const p = await PERMISSION_QUERY.permission({permission_object:permission, address:pair!.toSuiAddress()});
+            const p = await query_permission({permission_object:permission, address:pair!.toSuiAddress()});
             if (checkOwner && !p.owner) ERROR(Errors.noPermission, 'owner');
             if (checkAdmin && !p.admin) ERROR(Errors.noPermission, 'admin');
 
@@ -99,7 +114,7 @@ export class CallBase {
                 }
             } 
             
-            return p!.future_fills();
+            return {guard:[...guards], witness:p!.future_fills()};
         } else { // no passport needed
             return this.exec()
         }
@@ -116,18 +131,4 @@ export class CallBase {
             options:{showObjectChanges:true},
         });
     }
-
-    static ResponseData(response: CallResponse | undefined ) : ResponseData[] {
-        const res : ResponseData[] = [];
-        response?.objectChanges?.forEach(v => {
-            const type_raw: string | undefined = (v as any)?.objectType;
-            const type:string | undefined = type_raw ? Protocol.Instance().object_name_from_type_repr(type_raw) : undefined;
-            if (type) {
-                res.push({type:type, type_raw:type_raw, object:(v as any)?.objectId, version:(v as any)?.version,
-                    owner:(v as any)?.owner, change:v.type
-                })
-            }
-        })
-        return res;
-    }
 }