enhancement: more changes to account commands

Author: dafuga

src/commands/account.ts

@@ -0,0 +1,28 @@
+/* eslint-disable no-console */
+import {Command} from 'commander'
+import {lookupAccount} from './chain/interact'
+import {getDefaultChain} from './chain/utils'
+
+/**
+ * Create the account command
+ */
+export function createAccountCommand(): Command {
+    const accountCommand = new Command('account')
+    accountCommand.description('Lookup account data on the blockchain')
+
+    accountCommand
+        .argument('<accountName>', 'Account name to lookup')
+        .option('-c, --chain <chainName>', 'Chain to query (default: local or configured default)')
+        .option('--json', 'Output as JSON')
+        .action(async (accountName, options) => {
+            try {
+                const chainName = options.chain || (await getDefaultChain())
+                await lookupAccount(chainName, accountName, options)
+            } catch (error: any) {
+                console.error(`Error: ${error.message}`)
+                process.exit(1)
+            }
+        })
+
+    return accountCommand
+}

src/commands/chain/index.ts

@@ -3,6 +3,7 @@ import {Command} from 'commander'
 import {showChainLogs, showChainStatus, startLocalChain, stopLocalChain} from './local'
 import {checkLeapInstallation} from './install'
 import {addInteractCommands, addInteractSubcommands} from './interact'
+import {setDefaultChain} from './utils'
 
 /**
  * Create the chain command with subcommands
@@ -84,6 +85,20 @@ export function createChainCommand(): Command {
             }
         })
 
+    // Set default chain
+    chain
+        .command('set <chainName>')
+        .description('Set the default chain for account lookups')
+        .action(async (chainName) => {
+            try {
+                await setDefaultChain(chainName)
+                console.log(`Default chain set to: ${chainName}`)
+            } catch (error: any) {
+                console.error(`Error: ${error.message}`)
+                process.exit(1)
+            }
+        })
+
     // Check installation
     chain
         .command('check')

src/commands/chain/utils.ts

@@ -280,3 +280,34 @@ export function createApiClientForPort(port: number): APIClient {
     const provider = new FetchProvider(url, {fetch})
     return new APIClient({provider})
 }
+
+/**
+ * Get the config file path for storing default chain preference
+ */
+export function getConfigFilePath(): string {
+    return path.join(getDefaultConfigDir(), 'default-chain.json')
+}
+
+/**
+ * Get the default chain name (defaults to 'local')
+ */
+export async function getDefaultChain(): Promise<string> {
+    const configFile = getConfigFilePath()
+    try {
+        const content = await fs.promises.readFile(configFile, 'utf-8')
+        const config = JSON.parse(content)
+        return config.chain || 'local'
+    } catch {
+        return 'local'
+    }
+}
+
+/**
+ * Set the default chain name
+ */
+export async function setDefaultChain(chainName: string): Promise<void> {
+    const configFile = getConfigFilePath()
+    await ensureDir(path.dirname(configFile))
+    const config = {chain: chainName}
+    await fs.promises.writeFile(configFile, JSON.stringify(config, null, 2))
+}

src/commands/compile.ts

@@ -2,7 +2,7 @@
 import {Command} from 'commander'
 import {execSync} from 'child_process'
 import {existsSync, mkdirSync, readdirSync, readFileSync, statSync} from 'fs'
-import {basename, dirname, extname, join, relative, resolve} from 'path'
+import {basename, dirname, extname, isAbsolute, join, normalize, relative, resolve} from 'path'
 import {checkLeapInstallation} from './chain/install'
 
 /**
@@ -19,7 +19,10 @@ export async function compileContract(file: string | undefined, outputDir: strin
         return
     }
 
-    const absoluteOutputDir = resolve(outputDir)
+    // Resolve output directory to absolute path, handling both relative and absolute paths
+    const absoluteOutputDir = isAbsolute(outputDir)
+        ? normalize(outputDir)
+        : normalize(resolve(outputDir))
     ensureOutputDirectory(absoluteOutputDir)
 
     // Ensure cdt-cpp is installed
@@ -92,11 +95,11 @@ export async function getFilesToCompile(
 }
 
 /**
- * Ensure output directory exists
+ * Ensure output directory exists, create it if it doesn't
  */
 function ensureOutputDirectory(dir: string): void {
     if (!existsSync(dir)) {
-        throw new Error(`Output directory does not exist: ${dir}`)
+        mkdirSync(dir, {recursive: true})
     }
 }
 
@@ -314,7 +317,15 @@ async function compileSingleFile(
         }
     } else {
         // Use path relative to current directory (preserve structure)
-        relativePath = relative(currentDir, filePath)
+        // But if the relative path goes outside currentDir (starts with ..), 
+        // just use the filename to avoid path issues
+        const relPath = relative(currentDir, filePath)
+        if (relPath.startsWith('..')) {
+            // If path goes outside current directory, just use filename
+            relativePath = basename(filePath, '.cpp')
+        } else {
+            relativePath = relPath
+        }
     }
 
     const relativeDir = dirname(relativePath)
@@ -326,7 +337,8 @@ async function compileSingleFile(
         wasmOutput = join(outputDir, `${fileName}.wasm`)
     } else {
         // File is in a subdirectory, preserve the structure (but without src/ prefix if stripped)
-        const outputSubDir = join(outputDir, relativeDir)
+        // Normalize the path to prevent issues with relative paths containing '..'
+        const outputSubDir = normalize(join(outputDir, relativeDir))
         // Ensure the output subdirectory exists
         if (!existsSync(outputSubDir)) {
             mkdirSync(outputSubDir, {recursive: true})

src/commands/wallet/account.ts

@@ -149,10 +149,22 @@ export async function createAccount(options: AccountCreateOptions): Promise<void
             if (response.status === 201) {
                 log('Account created successfully!', 'info')
                 log(`Account Name: ${accountName}`, 'info')
+                log(`Public Key: ${publicKey}`, 'info')
+
+                // Import the private key into the wallet
                 if (privateKey) {
-                    log(`Private Key: ${privateKey.toString()}`, 'info')
+                    try {
+                        addKeyToWallet(privateKey, String(accountName))
+                        log(`✅ Private key imported into wallet as: ${accountName}`, 'info')
+                    } catch (error) {
+                        log(
+                            `⚠️  Could not import key into wallet (may already exist): ${
+                                (error as Error).message
+                            }`,
+                            'info'
+                        )
+                    }
                 }
-                log(`Public Key: ${publicKey}`, 'info')
             } else {
                 const responseData = await response.json()
                 log(
@@ -319,25 +331,24 @@ async function createAccountOnLocalChain(
 
     log('Account created successfully!', 'info')
     log(`Account Name: ${accountName}`, 'info')
-    if (privateKey) {
-        log(`Private Key: ${privateKey.toString()}`, 'info')
-    }
     log(`Public Key: ${publicKey}`, 'info')
     log(`Transaction ID: ${result.resolved?.transaction.id}`, 'info')
 
-    // Store the key in wallet with account name (only if we have a private key)
+    // Import the private key into the wallet (only if we have a private key)
     if (privateKey) {
         try {
             addKeyToWallet(privateKey, accountName)
-            log(`Key stored in wallet as: ${accountName}`, 'info')
+            log(`✅ Private key imported into wallet as: ${accountName}`, 'info')
         } catch (error) {
             log(
-                `Could not store key in wallet (may already exist): ${(error as Error).message}`,
+                `⚠️  Could not import key into wallet (may already exist): ${
+                    (error as Error).message
+                }`,
                 'info'
             )
         }
     } else {
-        log('Note: No private key available to store in wallet (public key was provided)', 'info')
+        log('Note: No private key available to import (public key was provided)', 'info')
     }
 }
 

src/index.ts

@@ -7,6 +7,7 @@ import {createChainCommand} from './commands/chain/index'
 import {createCompileCommand} from './commands/compile'
 import {createDevCommand} from './commands/dev'
 import {createWalletCommand} from './commands/wallet/index'
+import {createAccountCommand} from './commands/account'
 
 const program = new Command()
 
@@ -48,4 +49,7 @@ program.addCommand(createDevCommand())
 // 7. Command to manage wallet (includes account creation)
 program.addCommand(createWalletCommand())
 
+// 8. Command to lookup account data
+program.addCommand(createAccountCommand())
+
 program.parse(process.argv)

test/tests/wallet-account.ts

@@ -5,25 +5,31 @@ import {Chains} from '@wharfkit/common'
 
 import {createAccount} from 'src/commands/wallet/account'
 import * as utils from 'src/utils'
+import * as walletUtils from 'src/commands/wallet/utils'
 
 suite('Wallet Account Create', () => {
     let sandbox: sinon.SinonSandbox
     let fetchStub: sinon.SinonStub
     let makeClientStub: sinon.SinonStub
     let logStub: sinon.SinonStub
+    let addKeyToWalletStub: sinon.SinonStub
 
     setup(function () {
         sandbox = sinon.createSandbox()
         fetchStub = sandbox.stub()
         makeClientStub = sandbox.stub()
         logStub = sandbox.stub()
+        addKeyToWalletStub = sandbox.stub()
 
         // Mock fetch from node-fetch
         sandbox.stub(nodeFetch, 'default').callsFake(fetchStub as any)
 
         // Mock makeClient and log from utils
         sandbox.stub(utils, 'makeClient').callsFake(makeClientStub as any)
         sandbox.stub(utils, 'log').callsFake(logStub as any)
+
+        // Mock addKeyToWallet from wallet utils
+        sandbox.stub(walletUtils, 'addKeyToWallet').callsFake(addKeyToWalletStub as any)
     })
 
     teardown(function () {
@@ -101,6 +107,8 @@ suite('Wallet Account Create', () => {
         // Should not log private key when key is provided
         const logCalls = logStub.getCalls().map((call) => call.args[0])
         assert.isFalse(logCalls.some((msg) => msg.includes('Private Key')))
+        // Should not import key when only public key is provided
+        assert.isFalse(addKeyToWalletStub.called)
     })
 
     test('generates private key when not provided', async function () {
@@ -116,9 +124,11 @@ suite('Wallet Account Create', () => {
         assert.isString(body.activeKey)
         assert.include(body.activeKey, 'PUB_K1_')
 
-        // Should log private key when it was generated
+        // Should import private key when it was generated (not log it)
         const logCalls = logStub.getCalls().map((call) => call.args[0])
-        assert.isTrue(logCalls.some((msg) => msg.includes('Private Key')))
+        assert.isFalse(logCalls.some((msg) => msg.includes('Private Key:')))
+        assert.isTrue(logCalls.some((msg) => msg.includes('Private key imported into wallet')))
+        assert.isTrue(addKeyToWalletStub.calledOnce)
     })
 
     test('creates account on KylinTestnet chain', async function () {