wowok_agent 1.2.40 → 1.2.41

package/src/local/account.ts

@@ -2,9 +2,9 @@
  * account management and use
  */
 
-import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey, Protocol, TransactionBlock, IsValidAddress,  
+import { Ed25519Keypair, fromHEX, toHEX, decodeSuiPrivateKey, Protocol, TransactionBlock, 
     getFaucetHost, requestSuiFromFaucetV0, requestSuiFromFaucetV1, CoinBalance, CoinStruct, TransactionArgument, TransactionResult, 
-    CallResponse, TransactionObjectArgument} from 'wowok';
+    CallResponse, TransactionObjectArgument, Errors, ERROR, IsValidName} from 'wowok';
 import { isBrowser } from '../common.js';
 import path from 'path';
 import os from 'os';
@@ -12,8 +12,16 @@ import { Level } from 'level';
 
 
 const AccountLocation = 'wowok-acc';
-const SettingDefault = 'default';
+const AccountKey = 'account';
 
+export interface AccountData {
+    address: string;
+    secret?: string;
+    pubkey?: string;
+    name?: string;
+    suspended?: boolean;
+    default?: boolean;
+}
 export class Account {
     private storage;
 
@@ -34,112 +42,226 @@ export class Account {
         }; return Account._instance
     }
     
-    async set_default(address?: string) : Promise<boolean> {
-        if (address) {
-            if (!await this.storage.get(address)) {
-                return false
+    private accountData(data:AccountData | undefined) : AccountData | undefined {
+        if (!data) return ;
+
+        data.pubkey = Ed25519Keypair.fromSecretKey(fromHEX(data.secret!)).getPublicKey().toSuiPublicKey();
+        data.secret = undefined;
+        return data;
+    }
+
+    async set_default(address_or_name: string) : Promise<boolean> {
+        const r = await this.storage.get(AccountKey);
+        var found = false;
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            for (let i = 0; i < s.length; i++) {
+                if (s[i].address === address_or_name || s[i].name === address_or_name && !found) {
+                    s[i].default = true;
+                    found = true;
+                } else {
+                    s[i].default = false;
+                }
             }
-            await this.storage.put(SettingDefault, address);
-        } else {
-            await this.storage.del(SettingDefault);
+            await this.storage.put(AccountKey, JSON.stringify(s));
         }
-        return true
+
+        return found;
     }
 
-    async gen(bDefault?: boolean) : Promise<string> {       
+    async gen(bDefault?: boolean, name?:string) : Promise<AccountData> {    
+        if (name && !IsValidName(name)) {
+            ERROR(Errors.IsValidName, `Name ${name} is not valid`);
+        }   
+
         var secret = '0x'+toHEX(decodeSuiPrivateKey(Ed25519Keypair.generate().getSecretKey()).secretKey);
         var address = Ed25519Keypair.fromSecretKey(fromHEX(secret)).getPublicKey().toSuiAddress();
-        await this.storage.put(address, secret);
-        if (bDefault) {
-            await this.storage.put(SettingDefault, address);
-        };
-        return address;
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            if (name) {
+                if (s.find(v => v.name === name)) {
+                    ERROR(Errors.IsValidName, `Name ${name} already exists`);
+                }
+            }
+            
+            if (bDefault) {
+                s.forEach(v => {
+                    if (v.default) {
+                        v.default = false;
+                    }
+                })
+            }
+
+            const ret:AccountData = {address: address, secret:secret, name: name ? name:undefined, default: bDefault};
+            s.push(ret);
+
+            await this.storage.put(AccountKey, JSON.stringify(s));
+            return this.accountData(ret)!;
+        } else {
+            const ret:AccountData = {address: address, secret:secret, name: name ? name:undefined, default: bDefault};
+            await this.storage.put(AccountKey, JSON.stringify([ret]));
+            return this.accountData(ret)!;
+        }
     }
 
-    async default(genNewIfnotExisted:boolean=true) : Promise<string | undefined> {
-        const r = await this.storage.get(SettingDefault);
+    async default() : Promise<AccountData | undefined> {
+        const r = await this.storage.get(AccountKey);
         if (r) {
-            return r;
-        } else if (genNewIfnotExisted) {
-            return await this.gen(true);
+            const s = JSON.parse(r) as AccountData[];
+            return this.accountData(s.find(v => v.default));
         } 
     }
 
     // address: if undefined, the default returned.
-    async get_pubkey(address?:string) : Promise<string | undefined> {
-        const secret: string | undefined = address? 
-            await this.storage.get(address) :
-            await this.default();
-        if (secret) {
-            return Ed25519Keypair.fromSecretKey(fromHEX(secret)).getPublicKey().toSuiPublicKey()
+    async get(address_or_name?: string) : Promise<AccountData | undefined> {
+        return this.accountData(await this.get_imp(address_or_name));
+    }
+
+    private async get_imp(address_or_name?: string) : Promise<AccountData | undefined> {
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            if (!address_or_name) {
+                return s.find(v => v.default);
+            }
+
+            return s.find(v => v.address === address_or_name || v.name === address_or_name);
         } 
     }
     
-    async list() : Promise<string[]> {
-        return (await this.storage.keys().all()).filter(v => v !== SettingDefault);
+    async get_many(address_or_names: (string | null | undefined)[]) : Promise<(AccountData | undefined)[]> {
+        return await this.get_many_imp(address_or_names).then(v => v.map(i => this.accountData(i)));
     }
-    
-    async faucet(address?:string) {
-        if (!address) {
-            address = await this.default();
+    private async get_many_imp(address_or_names: (string | null | undefined)[]) : Promise<(AccountData | undefined)[]> {
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            return address_or_names.map(i => {
+                if (!i) {
+                    return s.find(v => v.default);
+                } else {
+                    return s.find(v => v.address === i || v.name === i);
+                }
+            })
         }
-
-        if (address) {
-            await requestSuiFromFaucetV0({host:getFaucetHost('testnet'), recipient:address}).catch(e => {})
+        return address_or_names.map(v => undefined);
+    }
+    async set_name(name:string, address?:string) : Promise<boolean> {
+        if (!IsValidName(name)) {
+            ERROR(Errors.IsValidName, `Name ${name} is not valid`);
         }
+
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            if (s.find(v => v.name === name)) {
+                ERROR(Errors.IsValidName, `Name ${name} already exists`); 
+            }
+
+            if (!address) {
+                const f = s.find(v => v.default);
+                if (f) {
+                    f.name = name;
+                    await this.storage.put(AccountKey, JSON.stringify(s));
+                    return true;
+                } 
+            } else {
+                const f = s.find(v => v.address === address);
+                if (f) {
+                    f.name = name;
+                    await this.storage.put(AccountKey, JSON.stringify(s));
+                    return true;
+                } 
+            }
+        } 
+        return false;
     }
 
-    async sign_and_commit(txb: TransactionBlock, address?:string) : Promise<CallResponse | undefined> {
-        const addr = address ? address : await this.default();
-        if (!addr) {
-            return undefined;
+    async list(showSuspended?:boolean) : Promise<AccountData[]> {        
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            if (showSuspended) {
+                return s.map(v => this.accountData(v)!);
+            } else {
+                return s.filter(v => !v.suspended).map(v => this.accountData(v)!);
+            }
+        } 
+        return [];
+    }
+    
+    async suspend(address_or_name?:string, suspend:boolean=true) : Promise<void> {
+        const r = await this.storage.get(AccountKey);
+        if (r) {
+            const s = JSON.parse(r) as AccountData[];
+            if (!address_or_name) {
+                const f = s.find(v => v.default);
+                if (f) {
+                    f.suspended = suspend;
+                } 
+            } else {
+                const f = s.find(v => v.address === address_or_name || v.name === address_or_name);
+                if (f) {
+                    f.suspended = suspend;
+                } 
+            }
+            await this.storage.put(AccountKey, JSON.stringify(s));
         }
+    }
 
-        const secret: string | undefined = await this.storage.get(addr);
+    async faucet(address_or_name?:string) {
+        const a = await this.get(address_or_name);
 
-        if (secret) {
-            return await Protocol.Client().signAndExecuteTransaction({
-                transaction: txb, 
-                signer: Ed25519Keypair.fromSecretKey(fromHEX(secret)),
-                options:{showObjectChanges:true},
-            });
+        if (a) {
+            await requestSuiFromFaucetV0({host:getFaucetHost('testnet'), recipient:a.address}).catch(e => {})
         }
     }
 
-    // token_type is 0x2::sui::SUI, if not specified.
-    balance = async (address?:string, token_type?:string) : Promise<CoinBalance | undefined> => {
-        if (!address) {
-            address = await this.default();
+    async sign_and_commit(txb: TransactionBlock, address_or_name?:string) : Promise<CallResponse | undefined> {
+        const a = await this.get_imp(address_or_name);
+        console.log('sign_and_commit', a, address_or_name);
+        if (a) {
+            const pair = Ed25519Keypair.fromSecretKey(fromHEX(a.secret!));
+            if (pair) {
+                return await Protocol.Client().signAndExecuteTransaction({
+                    transaction: txb, 
+                    signer: pair,
+                    options:{showObjectChanges:true},
+                });
+            } 
         }
+    }
 
-        if (address) {
-            return await Protocol.Client().getBalance({owner: address, coinType:token_type});
+    // token_type is 0x2::sui::SUI, if not specified.
+    balance = async (address_or_name?:string, token_type?:string) : Promise<CoinBalance | undefined> => {
+        const a = await this.get(address_or_name);
+        const token_type_ = token_type ?? '0x2::sui::SUI';
+        if (a) {
+            return await Protocol.Client().getBalance({owner: a.address, coinType:token_type_});
         }
     }
 
     // token_type is 0x2::sui::SUI, if not specified.
-    coin = async (address?:string, token_type?:string) : Promise<CoinStruct[] | undefined> => {
-        if (!address) {
-            address = await this.default();
-        }
-        if (address) {
-            return (await Protocol.Client().getCoins({owner: address, coinType:token_type})).data;
+    coin = async (token_type?:string, address_or_name?:string) : Promise<CoinStruct[] | undefined> => {
+        const a = await this.get(address_or_name);
+        const token_type_ = token_type ?? '0x2::sui::SUI';
+        if (a) {
+            return (await Protocol.Client().getCoins({owner: a.address, coinType:token_type_})).data;
         }
     }
 
-    get_coin_object = async (txb: TransactionBlock, balance_required:string | bigint | number, address?:string, token_type?:string) : Promise<TransactionResult | undefined> => {
-        if (!address) {
-            address = await this.default();
-        }
+    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 (address) {
+        if (a) {
             const b = BigInt(balance_required);
 
             if (b >= BigInt(0)) {
                 if (!token_type || token_type === '0x2::sui::SUI' || token_type === '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI') {
                     return txb.splitCoins(txb.gas, [b]);
                 } else {
-                    const r = await Protocol.Client().getCoins({owner: address, coinType:token_type});
+                    const r = await Protocol.Client().getCoins({owner: a.address , coinType:token_type});
                     const objects : string[] = []; var current = BigInt(0);
                     for (let i = 0; i < r.data.length; ++ i) {
                         current += BigInt(r.data[i].balance);
@@ -160,41 +282,39 @@ export class Account {
             }
         }
     }
-    async transfer(from:string, to:string, amount:number|string, token_type?:string) : Promise<CallResponse | undefined> {
-        const secret: string | undefined = await this.storage.get(from);    
-        if (!secret)    return undefined;
-        const pair = Ed25519Keypair.fromSecretKey(fromHEX(secret))
-        if (!pair) return undefined;
+    async transfer(amount:number|string, token_type?:string, to_address_or_name?:string, from_address_or_name?:string) : Promise<CallResponse | undefined> {
+        const [from, to]= await this.get_many_imp([from_address_or_name, to_address_or_name]);
+        if (!from) ERROR(Errors.InvalidParam, `Invalid from address or name ${from_address_or_name}`);
+        const to_address = to?.address ?? to_address_or_name;
+        if (!to_address) ERROR(Errors.InvalidParam, `Invalid to address or name ${to_address_or_name}`);
 
-        const txb = new TransactionBlock();
-        const coin = await this.get_coin_object(txb, amount, from, token_type);
-        if (coin) {
-            txb.transferObjects([coin as TransactionObjectArgument], to)
-            const r = await Protocol.Client().signAndExecuteTransaction({
-                transaction: txb, 
-                signer: pair,
-                options:{showObjectChanges:true},
-            });
-            return r;
+        const pair = Ed25519Keypair.fromSecretKey(fromHEX(from.secret!))
+        if (pair) {
+            const txb = new TransactionBlock();
+            const coin = await this.get_coin_object(txb, amount, from.address, token_type);
+            if (coin) {
+                txb.transferObjects([coin as TransactionObjectArgument], to_address)
+                const r = await Protocol.Client().signAndExecuteTransaction({
+                    transaction: txb, 
+                    signer: pair,
+                    options:{showObjectChanges:true},
+                });
+                return r;
+            }
         }
     }
 
-    coinObject_with_balance = async(balance_required:string | bigint | number, address?:string, token_type?:string) : Promise<string | undefined> => {
-        if (!address) {
-            address = await this.default();
-        }
-
-        if (!address) return undefined;
-        const secret = await this.storage.get(address);
-        if (!secret) return undefined;
+    coinObject_with_balance = async(balance_required:string | bigint | number, address_or_name?:string, token_type?:string) : Promise<string | undefined> => {
+        const a = await this.get_imp(address_or_name);
+        if (!a) return undefined;
 
-        const pair = Ed25519Keypair.fromSecretKey(fromHEX(secret))
+        const pair = Ed25519Keypair.fromSecretKey(fromHEX(a.secret!))
         if (!pair) return undefined;
     
         const txb = new TransactionBlock();
-        const res = await this.get_coin_object(txb, balance_required, address, token_type);
+        const res = await this.get_coin_object(txb, balance_required, a.address, token_type);
         if (res) {
-            txb.transferObjects([res as TransactionObjectArgument], address)
+            txb.transferObjects([res as TransactionObjectArgument], a.address)
             const r = await Protocol.Client().signAndExecuteTransaction({
                 transaction: txb, 
                 signer: pair,

package/src/local/index.ts

@@ -1,27 +1,19 @@
-import { CallResponse, CoinBalance, CoinStruct } from "wowok"
-import { Account } from "./account.js"
+import { CallResponse, CoinBalance, CoinStruct, Protocol } from "wowok"
+import { Account, AccountData } from "./account.js"
 import { LocalInfo, LocalInfoNameDefault, LocalMark, LocalMarkFilter, MarkData } from "./local.js"
 
 export const query_local_mark_list = async (filter?:LocalMarkFilter) : Promise<string> => {
     return JSON.stringify(await LocalMark.Instance().list(filter))
 }
 
-export const query_account_list = async () : Promise<QueryAccountsResult> => {
-    const res : QueryAccountsResult = {};
-    res.addresses = await Account.Instance().list();
-    res.default = await Account.Instance().default(false);
-    return res;
+export const query_account_list = async (showSuspendedAccount?:boolean) : Promise<AccountData[]> => {
+    return await Account.Instance().list(showSuspendedAccount);
 }
 
 export const query_local_info_list = async () : Promise<string> => {
     return JSON.stringify(await LocalInfo.Instance().list())
 }
 
-export interface QueryAccountsResult {
-    default?: string;
-    addresses?: string[];
-}
-
 export const query_local_mark = async (name: string) : Promise<MarkData | undefined> => {
     return await LocalMark.Instance().get(name)
 }
@@ -46,15 +38,19 @@ export interface QueryAccountResult {
 }
 
 export const query_account = async (query: QueryAccount) : Promise<QueryAccountResult> => {
-    const r = await LocalMark.Instance().get_account(query.name_or_address);
-    const res : QueryAccountResult = {address: r};
-    if (query.name_or_address) { res.name_or_address = query.name_or_address; }
+    const r = await Account.Instance().get(query.name_or_address);
+    if (!r) {
+        return {name_or_address: query.name_or_address};
+    }
+
+    const res : QueryAccountResult = {address: r.address, name_or_address: r.name};
 
     if (r) {
+        const token_type_ = query.token_type ?? '0x2::sui::SUI';
         if (query?.balance_or_coin === BalanceOrCoin.Balance) {
-            res.balance = await Account.Instance().balance(r, query.token_type);
+            res.balance = await Protocol.Client().getBalance({owner: r.address, coinType:token_type_});
         } else if (query?.balance_or_coin === BalanceOrCoin.Coin) {
-            res.coin =  await Account.Instance().coin(r, query.token_type);
+            res.coin = (await Protocol.Client().getCoins({owner: r.address, coinType:token_type_})).data;
         } 
     } 
     
@@ -66,29 +62,36 @@ export const query_local_info = async (name: string = LocalInfoNameDefault) : Pr
 }
 
 export interface AccountOperation {
-    gen?: {name?:string, default?: boolean, useAddressIfNameExist?: boolean} | null;
-    transfer?: {name_or_address_from?: string, name_or_address_to?:string, amount:number|string, token_type?: string} | null; 
+    gen?: {name?:string, default?: boolean} | null; // generate a new account, if not specified, generate a new default account.
+    default?: {name_or_address: string} | null; // set the default account.
+    suspend?: {name_or_address?: string, suspend?:boolean} | null; // suspend the account, if not specified, suspend the default account.
+    name?: {name:string, address?:string} | null; // name the account, if not specified, name the default account.
+    transfer?: {name_or_address_from?: string, name_or_address_to?:string, amount:number|string, token_type?: string} | null;   // transfer the token.
 }
 
 export interface AccountOperationResult {
-    gen?: {address:string, default:boolean, name: string};
+    gen?: {address:string, default?:boolean, name?: string};
     transfer?: CallResponse;
 }
 
 export const account_operation = async(op: AccountOperation) : Promise<AccountOperationResult> => {
     var res : AccountOperationResult = {}; 
     if (op.gen) {
-        const acc = await Account.Instance().gen(op.gen?.default);
-        const name = await LocalMark.Instance().put(op.gen.name, {object: acc, tags: ['account']}, op.gen.useAddressIfNameExist);
-        res.gen =  {address: acc, default: op.gen.default ?? false, name:name};
+        const acc = await Account.Instance().gen(op.gen?.default, op.gen?.name);
+        res.gen =  {address: acc?.address, default: acc?.default, name:acc?.name};
     } 
-    
+    if (op.default) {
+        await Account.Instance().set_default(op.default.name_or_address); 
+    }
+    if (op.suspend) {
+        await Account.Instance().suspend(op.suspend.name_or_address, op.suspend.suspend);
+    }
+    if (op.name) {
+        await Account.Instance().set_name(op.name.name, op.name.address); 
+    }
+
     if(op.transfer) {
-        const from = await LocalMark.Instance().get_account(op.transfer?.name_or_address_from, false);
-        const to = await LocalMark.Instance().get_account(op.transfer.name_or_address_to, false);
-        if (from && to) {
-            res.transfer = await Account.Instance().transfer(from, to, op.transfer?.amount, op.transfer?.token_type);
-        }
+        res.transfer = await Account.Instance().transfer(op.transfer.amount, op.transfer.token_type, op.transfer.name_or_address_from, op.transfer.name_or_address_to);
     }
     return res;
 }

package/src/local/local.ts

@@ -8,7 +8,6 @@ import os from "os";
 import { Level } from "level";
 import { isBrowser } from "../common.js";
 import { ERROR, Errors, IsValidAddress, TagName } from "wowok";
-import { Account } from "./account.js";
 
 export interface MarkData {
     object: string;
@@ -121,31 +120,6 @@ export class LocalMark {
       return (await this.get_many_address(name_or_addresses)).filter(v => v!==undefined && v!== null) as string[]
     }
 
-    // get account address:
-    // 1. if name_or_address is undefined, return default account address.
-    // 2. if name_or_address is address, return it.
-    // 3. if name_or_address is name, return the address of the name.
-    // 4. if not found and genNewIfNotFound is true, generate a new address and save it with name_or_address.
-    async get_account(name_or_address?: string, genNewIfNotFound:boolean=false) : Promise<string | undefined> {
-      if (name_or_address === undefined) {
-          return Account.Instance().default(genNewIfNotFound);
-      } else {
-        const r = await this.get(name_or_address);
-        if (r) {
-          return r.object;
-        } else {
-          if (IsValidAddress(name_or_address)) {
-            return name_or_address;
-          }
-  
-          if (genNewIfNotFound) {
-            const addr = await Account.Instance().gen(false);
-            await this.put(name_or_address, {object:addr, tags:[TagName.Account]});
-          }
-        }
-      }
-    }
-
     async del(name:string)  {
       return await this.storage.del(name);
     }