@airmoney-degn/airmoney-cli 0.11.4 → 0.13.0

package/dist/cli/serve.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -47,9 +14,7 @@ const express_ws_1 = __importDefault(require("express-ws"));
 const metadata_1 = require("../util/metadata");
 const server_1 = require("../util/server");
 const http_proxy_middleware_1 = require("http-proxy-middleware");
-const ChildProcess = __importStar(require("child_process"));
-const fs_1 = require("fs");
-const env_1 = require("../util/env");
+const cryptoProcess_1 = require("../util/cryptoProcess");
 /**
  * Helper to get the path to the "public/simulator" folder
  * from the distributed code. We use __dirname, then move
@@ -63,6 +28,17 @@ function getSimulatorDir() {
     return path_1.default.join(base, 'public', 'simulator');
 }
 async function serveCommand(noBrowser, locationFolder, appUrl) {
+    // Check if simulator and API ports are already in use (crypto service handles its own port)
+    const requiredPorts = [4040, 4041, 5050];
+    const inUsePorts = await (0, cryptoProcess_1.checkPortsInUse)(requiredPorts);
+    if (inUsePorts.length > 0) {
+        console.error('\x1b[31m❌ Port conflict detected!\x1b[0m');
+        console.error(`\x1b[31mThe following ports are already in use: ${inUsePorts.join(', ')}\x1b[0m`);
+        console.error('\x1b[31m\nPlease kill the processes using these ports before running serve:\x1b[0m');
+        const killCommand = `lsof -ti:${inUsePorts.join(',')} | xargs kill -9`;
+        console.error(`\x1b[31m  ${killCommand}\x1b[0m`);
+        process.exit(1);
+    }
     const simulatorPort = 4041;
     const simulatorExpress = (0, express_ws_1.default)((0, express_1.default)()).app;
     simulatorExpress.use((0, cors_1.default)());
@@ -73,7 +49,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
         ws.on('message', function (msg) {
             console.log(msg);
         });
-        console.log('socket', req.body);
+        // console.log('socket', req.body);
     });
     const simulatorDir = getSimulatorDir();
     simulatorExpress.use('/simulator', express_1.default.static(simulatorDir));
@@ -84,7 +60,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     }
     const metadata = (0, metadata_1.loadMetadata)();
     if (!metadata) {
-        console.log('[Warning] No metadata found. Skipping some possible checks.');
+        console.log('\x1b[33mNo metadata found. Skipping some possible checks.\x1b[0m');
     }
     if (appUrl != undefined) {
         const proxyMiddleware = (0, http_proxy_middleware_1.createProxyMiddleware)({
@@ -100,14 +76,14 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     }
     const simulatorServer = simulatorExpress.listen(simulatorPort, () => {
         const url = `http://localhost:${simulatorPort}/simulator`;
-        console.log(`Starting simulator server at ${url}`);
+        console.log(`\x1b[32mStarting simulator server at ${url}\x1b[0m`);
         if (!noBrowser) {
             (0, open_1.default)(url)
                 .then(() => {
                 // success opening URL
             })
                 .catch(err => {
-                console.error('Failed to open web browser', err);
+                console.error('\x1b[31mFailed to open web browser\x1b[0m', err);
             });
         }
     });
@@ -134,7 +110,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
                     return;
                 }
                 else {
-                    console.log('Warning: No simulator client connected');
+                    console.log('\x1b[33mNo simulator client connected\x1b[0m');
                     res.status(503).json({ error: 'Simulator not connected' });
                     return;
                 }
@@ -151,19 +127,8 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     });
     const airmoneyServiceServer = airmoneyServiceExpress.listen(airmoneyServicePort, () => {
         const url = `http://localhost:${airmoneyServicePort}`;
-        console.log(`Starting airmoney service server at ${url}`);
+        console.log(`\x1b[32mStarting airmoney service server at ${url}\x1b[0m`);
     });
     ////////////////////////////////////////////////////////////////
-    const cryptoServiceBin = `${process.platform}-${process.arch}`;
-    const bin = path_1.default.join(__dirname, '..', 'bin', cryptoServiceBin);
-    if (!(0, fs_1.existsSync)(bin)) {
-        console.log('crypto service not found at ' + bin);
-    }
-    else {
-        console.log('execing crypto service at http://localhost:5050');
-        ChildProcess.exec(bin, { env: { SECURE_STORAGE: (0, env_1.configDir)(), RUST_BACKTRACE: '1' } }, (_, stdout, stderr) => {
-            console.log(stdout);
-            console.log(stderr);
-        });
-    }
+    (0, cryptoProcess_1.startCryptoServiceSimple)();
 }

package/dist/cli/wallet.js

@@ -41,12 +41,16 @@ exports.listWallet = listWallet;
 exports.importWalletSk = importWalletSk;
 exports.importSvmWallet = importSvmWallet;
 exports.exportWalletSk = exportWalletSk;
+exports.generateWallet = generateWallet;
+exports.setDefaultWallet = setDefaultWallet;
+exports.getDefaultWallet = getDefaultWallet;
 const fs_1 = require("fs");
 const env_1 = require("../util/env");
 const path_1 = __importDefault(require("path"));
 const ethers_1 = require("ethers");
 const bs58 = __importStar(require("bs58"));
 const web3_js_1 = require("@solana/web3.js");
+const cryptoProcess_1 = require("../util/cryptoProcess");
 async function deleteWallet(address, chainName) {
     const config = (0, env_1.configDir)();
     const walletPath = path_1.default.join(config, chainName);
@@ -59,45 +63,32 @@ async function deleteWallet(address, chainName) {
     (0, fs_1.rmSync)(walletFile);
 }
 async function listWallet(chainName) {
-    const config = (0, env_1.configDir)();
-    const walletPath = path_1.default.join(config, 'wallet', chainName);
-    if (!(0, fs_1.existsSync)(walletPath)) {
-        (0, fs_1.mkdirSync)(walletPath, {
-            recursive: true,
+    try {
+        const wallets = await (0, cryptoProcess_1.withCryptoService)(async (cryptoServiceClient) => {
+            switch (chainName) {
+                case 'evm':
+                    return await cryptoServiceClient.listEvmWallets();
+                case 'svm':
+                    return await cryptoServiceClient.listSolanaWallets();
+                case 'btc':
+                    return await cryptoServiceClient.listBitcoinWallets();
+                default:
+                    throw new Error(`Unsupported chain: ${chainName}`);
+            }
         });
+        // Display wallets
+        wallets.wallets.forEach((address) => {
+            console.log(address);
+        });
+        return wallets;
+    }
+    catch (error) {
+        console.error('Failed to list wallets:', error instanceof Error ? error.message : String(error));
+        throw error;
     }
-    const files = (0, fs_1.readdirSync)(walletPath)
-        .map(file => file.split('.json')[0])
-        .reduce((acc, address) => {
-        if (address === 'default') {
-            const defaultAddress = (0, fs_1.readFileSync)(path_1.default.join(walletPath, 'default'), 'utf8');
-            const existingDefaultItem = acc.find(item => item.address === defaultAddress);
-            if (existingDefaultItem) {
-                existingDefaultItem.default = true;
-            }
-            else {
-                acc.push({ address: defaultAddress, default: true });
-            }
-            return acc;
-        }
-        else {
-            acc.push({ address, default: false });
-        }
-        return acc;
-    }, [])
-        .forEach(item => {
-        console.log(`${item.address} ${item.default ? '(default)' : ''}`);
-    });
-    return files;
 }
 async function importWalletSk(PrivateKey, chainName) {
-    const config = (0, env_1.configDir)();
-    const walletPath = path_1.default.join(config, chainName);
-    if (!(0, fs_1.existsSync)(walletPath)) {
-        (0, fs_1.mkdirSync)(walletPath, {
-            recursive: true,
-        });
-    }
+    (0, cryptoProcess_1.ensureWalletDirectory)(chainName);
     if (chainName == 'evm') {
         await importEvmWallet(PrivateKey);
     }
@@ -106,13 +97,7 @@ async function importWalletSk(PrivateKey, chainName) {
     }
 }
 async function importEvmWallet(PrivateKey) {
-    const config = (0, env_1.configDir)();
-    const walletPath = path_1.default.join(config, 'wallet', 'evm');
-    if (!(0, fs_1.existsSync)(walletPath)) {
-        (0, fs_1.mkdirSync)(walletPath, {
-            recursive: true,
-        });
-    }
+    const walletPath = (0, cryptoProcess_1.ensureWalletDirectory)('evm');
     if (PrivateKey.startsWith('0x') == false) {
         PrivateKey = '0x' + PrivateKey;
     }
@@ -123,13 +108,7 @@ async function importEvmWallet(PrivateKey) {
     }, null, 2));
 }
 async function importSvmWallet(privateKey) {
-    const config = (0, env_1.configDir)();
-    const walletPath = path_1.default.join(config, 'wallet', 'svm');
-    if (!(0, fs_1.existsSync)(walletPath)) {
-        (0, fs_1.mkdirSync)(walletPath, {
-            recursive: true,
-        });
-    }
+    const walletPath = (0, cryptoProcess_1.ensureWalletDirectory)('svm');
     const bytes = bs58.decode(privateKey);
     const wallet = web3_js_1.Keypair.fromSecretKey(bytes);
     (0, fs_1.writeFileSync)(path_1.default.join(walletPath, wallet.publicKey + '.json'), JSON.stringify({
@@ -138,13 +117,7 @@ async function importSvmWallet(privateKey) {
     }, null, 2));
 }
 async function exportWalletSk(address, chainName) {
-    const config = (0, env_1.configDir)();
-    const walletPath = path_1.default.join(config, 'wallet', chainName);
-    if (!(0, fs_1.existsSync)(walletPath)) {
-        (0, fs_1.mkdirSync)(walletPath, {
-            recursive: true,
-        });
-    }
+    const walletPath = (0, cryptoProcess_1.ensureWalletDirectory)(chainName);
     let walletFile;
     try {
         walletFile = (0, fs_1.readFileSync)(path_1.default.join(walletPath, address + '.json'));
@@ -156,3 +129,68 @@ async function exportWalletSk(address, chainName) {
     const wallet = JSON.parse(walletFile.toString());
     console.log(wallet.private_key);
 }
+async function generateWallet(chainName) {
+    try {
+        const walletData = await (0, cryptoProcess_1.withCryptoService)(async (cryptoServiceClient) => {
+            switch (chainName) {
+                case 'evm':
+                    return await cryptoServiceClient.generateEvmWallet();
+                case 'svm':
+                    return await cryptoServiceClient.generateSolanaWallet();
+                case 'btc':
+                    return await cryptoServiceClient.generateBitcoinWallet();
+                default:
+                    throw new Error(`Unsupported chain: ${chainName}`);
+            }
+        });
+        console.log(`Generated ${chainName} wallet: ${walletData.address}`);
+        return walletData;
+    }
+    catch (error) {
+        console.error('Failed to generate wallet:', error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}
+async function setDefaultWallet(address, chainName) {
+    try {
+        await (0, cryptoProcess_1.withCryptoService)(async (cryptoServiceClient) => {
+            switch (chainName) {
+                case 'evm':
+                    return await cryptoServiceClient.setDefaultEvmWallet(address);
+                case 'svm':
+                    return await cryptoServiceClient.setDefaultSvmWallet(address);
+                case 'btc':
+                    return await cryptoServiceClient.setDefaultBitcoinWallet(address);
+                default:
+                    throw new Error(`Unsupported chain: ${chainName}`);
+            }
+        });
+        console.log(`Set ${chainName} default wallet to: ${address}`);
+    }
+    catch (error) {
+        console.error('Failed to set default wallet:', error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}
+async function getDefaultWallet(chainName) {
+    try {
+        const walletData = await (0, cryptoProcess_1.withCryptoService)(async (cryptoServiceClient) => {
+            switch (chainName) {
+                case 'evm':
+                    return await cryptoServiceClient.getDefaultEvmWallet();
+                case 'svm':
+                    return await cryptoServiceClient.getDefaultSvmWallet();
+                case 'btc':
+                    return await cryptoServiceClient.getDefaultBitcoinWallet();
+                default:
+                    throw new Error(`Unsupported chain: ${chainName}`);
+            }
+        });
+        console.log(`Default ${chainName} wallet: ${walletData.address}`);
+        return walletData;
+    }
+    catch (error) {
+        console.error('Failed to get default wallet:', error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}

package/dist/config.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.11.4"
+    "version": "0.13.0"
 }

package/dist/index.js

@@ -61,9 +61,12 @@ program
     .option('-d, --delete <string>', 'delete wallet')
     .option('-i, --import <string>', 'import wallet')
     .option('-e, --export <string>', 'export wallet')
-    .option('-c, --chain [evm | svm]', 'chain name ', 'evm')
+    .option('-g, --generate', 'generate new wallet')
+    .option('-sd, --set-default <string>', 'set default wallet')
+    .option('-gd, --get-default', 'get default wallet')
+    .option('-c, --chain [evm | svm | btc]', 'chain name ', 'evm')
     .action(async (opts) => {
-    const { list, delete: del, import: importWallet, export: exportWallet, chain, } = opts;
+    const { list, delete: del, import: importWallet, export: exportWallet, generate, setDefault, getDefault, chain, } = opts;
     if (list) {
         await (0, wallet_1.listWallet)(chain);
     }
@@ -76,6 +79,15 @@ program
     else if (exportWallet) {
         await (0, wallet_1.exportWalletSk)(exportWallet, chain);
     }
+    else if (generate) {
+        await (0, wallet_1.generateWallet)(chain);
+    }
+    else if (setDefault) {
+        await (0, wallet_1.setDefaultWallet)(setDefault, chain);
+    }
+    else if (getDefault) {
+        await (0, wallet_1.getDefaultWallet)(chain);
+    }
 });
 program
     .command('upload')

package/dist/service/crypto/BaseCryptoService.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCryptoService = void 0;
+class BaseCryptoService {
+    constructor(baseURL = 'http://localhost:5050') {
+        this.createPayload = (method, params) => {
+            return {
+                id: new Date().getTime().toString(),
+                jsonrpc: '2.0',
+                method,
+                params,
+            };
+        };
+        this.request = async (payload) => {
+            const response = await fetch(this.baseURL, {
+                method: 'POST',
+                body: JSON.stringify(payload),
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`Crypto service error: ${response.status}`);
+            }
+            const result = (await response.json());
+            if ('error' in result) {
+                throw new Error(`Crypto service error: ${result.error.message}`);
+            }
+            return result.result;
+        };
+        this.baseURL = baseURL;
+    }
+}
+exports.BaseCryptoService = BaseCryptoService;

package/dist/service/crypto/CryptoService.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoService = void 0;
+const BaseCryptoService_1 = require("./BaseCryptoService");
+class CryptoService extends BaseCryptoService_1.BaseCryptoService {
+    constructor(baseURL = 'http://localhost:5050') {
+        super(baseURL);
+        // EVM Operations
+        this.generateEvmWallet = async (params = {}) => {
+            const payload = this.createPayload('generateEvmWallet', [params]);
+            return await this.request(payload);
+        };
+        this.listEvmWallets = async () => {
+            const payload = this.createPayload('listEvmWallets', []);
+            return await this.request(payload);
+        };
+        this.signEvmMessage = async (params) => {
+            const payload = this.createPayload('signEvmMessage', [
+                params.address,
+                params.message,
+            ]);
+            return await this.request(payload);
+        };
+        this.signEvmTransaction = async (params) => {
+            const payload = this.createPayload('signEvmTransaction', [
+                params.address,
+                params.transaction,
+                params.chainId,
+            ]);
+            return await this.request(payload);
+        };
+        this.signGeneralEvmTransaction = async (params) => {
+            const payload = this.createPayload('signGeneralEvmTransaction', [
+                params.address,
+                params.transaction,
+                params.chainId,
+            ]);
+            return await this.request(payload);
+        };
+        this.signEip712TypedData = async (params) => {
+            const payload = this.createPayload('signEip712TypedData', [
+                { address: params.address, typed_data: params.typedData },
+            ]);
+            return await this.request(payload);
+        };
+        this.verifyEip1271Signature = async (params) => {
+            const payload = this.createPayload('verifyEip1271Signature', [
+                params.rpcUrl,
+                params.contractAddress,
+                params.message,
+                params.signature,
+            ]);
+            return await this.request(payload);
+        };
+        this.signEVMRawTransaction = async (params) => {
+            const chainIdHex = typeof params.chainId === 'number'
+                ? params.chainId.toString()
+                : params.chainId;
+            return await this.signGeneralEvmTransaction({
+                address: params.address,
+                transaction: params.rawTransaction,
+                chainId: chainIdHex,
+            });
+        };
+        this.restoreEvmWallet = async (params) => {
+            const payload = this.createPayload('restoreEvmWallet', [params]);
+            return await this.request(payload);
+        };
+        this.setDefaultEvmWallet = async (walletAddress) => {
+            const payload = this.createPayload('setDefaultEvmWallet', [walletAddress]);
+            return await this.request(payload);
+        };
+        this.getDefaultEvmWallet = async () => {
+            const payload = this.createPayload('getDefaultEvmWallet', []);
+            return await this.request(payload);
+        };
+        // Solana Operations
+        this.generateSolanaWallet = async (params = {}) => {
+            const payload = this.createPayload('generateSolanaWallet', [params]);
+            return await this.request(payload);
+        };
+        this.listSolanaWallets = async () => {
+            const payload = this.createPayload('listSolanaWallets', []);
+            return await this.request(payload);
+        };
+        this.getSvmOptions = async () => {
+            const payload = this.createPayload('getSvmOptions', []);
+            return await this.request(payload);
+        };
+        this.signSolanaMessage = async (params) => {
+            const payload = this.createPayload('signSolanaMessage', [
+                params.address,
+                params.message,
+            ]);
+            return await this.request(payload);
+        };
+        this.signSolanaTransaction = async (params) => {
+            const payload = this.createPayload('signSolanaTransaction', [params]);
+            return await this.request(payload);
+        };
+        this.restoreSvmWallet = async (params) => {
+            const payload = this.createPayload('restoreSvmWallet', [params]);
+            return await this.request(payload);
+        };
+        this.setDefaultSvmWallet = async (walletAddress) => {
+            const payload = this.createPayload('setDefaultSvmWallet', [walletAddress]);
+            return await this.request(payload);
+        };
+        this.getDefaultSvmWallet = async () => {
+            const payload = this.createPayload('getDefaultSvmWallet', []);
+            return await this.request(payload);
+        };
+        // Bitcoin Operations
+        this.generateBitcoinWallet = async (params = {}) => {
+            const payload = this.createPayload('generateBitcoinWallet', [params]);
+            return await this.request(payload);
+        };
+        this.listBitcoinWallets = async () => {
+            const payload = this.createPayload('listBitcoinWallets', []);
+            return await this.request(payload);
+        };
+        this.getBitcoinWalletInfo = async (params) => {
+            const payload = this.createPayload('getBitcoinWalletInfo', [
+                params.address,
+            ]);
+            return await this.request(payload);
+        };
+        this.signBitcoinMessage = async (params) => {
+            const payload = this.createPayload('signBitcoinMessage', [
+                params.address,
+                params.message,
+            ]);
+            return await this.request(payload);
+        };
+        this.verifyBitcoinSignature = async (params) => {
+            const payload = this.createPayload('verifyBitcoinSignature', [
+                params.address,
+                params.message,
+                params.signature,
+            ]);
+            return await this.request(payload);
+        };
+        this.signBitcoinTransaction = async (params) => {
+            const payload = this.createPayload('signBitcoinTransaction', [params]);
+            return await this.request(payload);
+        };
+        this.restoreBitcoinWallet = async (params) => {
+            const payload = this.createPayload('restoreBitcoinWallet', [params]);
+            return await this.request(payload);
+        };
+        this.setDefaultBitcoinWallet = async (walletAddress) => {
+            const payload = this.createPayload('setDefaultBitcoinWallet', [
+                walletAddress,
+            ]);
+            return await this.request(payload);
+        };
+        this.getDefaultBitcoinWallet = async () => {
+            const payload = this.createPayload('getDefaultBitcoinWallet', []);
+            return await this.request(payload);
+        };
+        this.getBitcoinOptions = async () => {
+            const payload = this.createPayload('getBitcoinOptions', []);
+            return await this.request(payload);
+        };
+        // Universal Wallet Operations
+        this.generateUniversalWallet = async (params = {}) => {
+            const payload = this.createPayload('generateUniversalWallet', [params]);
+            return await this.request(payload);
+        };
+        this.restoreUniversalWallet = async (params) => {
+            const payload = this.createPayload('restoreUniversalWallet', [params]);
+            return await this.request(payload);
+        };
+    }
+}
+exports.CryptoService = CryptoService;

package/dist/service/crypto/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/cryptoProcess.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPortInUse = isPortInUse;
+exports.checkPortsInUse = checkPortsInUse;
+exports.isCryptoServiceRunning = isCryptoServiceRunning;
+exports.startCryptoService = startCryptoService;
+exports.getCryptoServicePath = getCryptoServicePath;
+exports.startCryptoServiceSimple = startCryptoServiceSimple;
+exports.ensureWalletDirectory = ensureWalletDirectory;
+exports.withCryptoService = withCryptoService;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const env_1 = require("./env");
+const CryptoService_1 = require("../service/crypto/CryptoService");
+// Utility functions for port management
+function isPortInUse(port) {
+    return new Promise(resolve => {
+        const net = require('net');
+        const socket = new net.Socket();
+        socket.setTimeout(1000);
+        socket.on('connect', () => {
+            socket.destroy();
+            resolve(true); // Port is in use
+        });
+        socket.on('timeout', () => {
+            socket.destroy();
+            resolve(false); // Port is free
+        });
+        socket.on('error', () => {
+            resolve(false); // Port is free
+        });
+        socket.connect(port, 'localhost');
+    });
+}
+async function checkPortsInUse(ports) {
+    const inUsePorts = [];
+    for (const port of ports) {
+        if (await isPortInUse(port)) {
+            inUsePorts.push(port);
+        }
+    }
+    return inUsePorts;
+}
+async function isCryptoServiceRunning(port = 5050) {
+    try {
+        // Check if crypto service is running by making a simple HTTP request
+        const response = await fetch(`http://localhost:${port}/`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(1000), // 1 second timeout
+        });
+        // Accept any response (200, 404, 405, etc.) as long as we get a response
+        // This means the crypto service is running
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function startCryptoService() {
+    return new Promise(async (resolve, reject) => {
+        const bin = getCryptoServicePath();
+        if (!(0, fs_1.existsSync)(bin)) {
+            reject(new Error(`Crypto service binary not found: ${bin}`));
+            return;
+        }
+        // Check if port 5050 is already in use before starting the binary
+        const portInUse = await isPortInUse(5050);
+        if (portInUse) {
+            // Check if it's our crypto service
+            const isCryptoRunning = await isCryptoServiceRunning(5050);
+            if (isCryptoRunning) {
+                // console.log('Reusing existing crypto service on port 5050');
+                // Return a mock process that doesn't need to be killed
+                resolve({
+                    process: null,
+                    kill: () => {
+                        // console.log('Crypto service is managed externally, not stopping');
+                    },
+                });
+                return;
+            }
+            else {
+                reject(new Error('Port 5050 is already in use by another service that is not the crypto service.\n' +
+                    'Please free up port 5050 or kill the conflicting process:\n' +
+                    '  lsof -ti:5050 | xargs kill -9'));
+                return;
+            }
+        }
+        // console.log('Starting crypto service...');
+        let isKilled = false;
+        let hasResolved = false;
+        const cryptoProcess = (0, child_process_1.exec)(bin, {
+            env: {
+                ...process.env,
+                SECURE_STORAGE: (0, env_1.configDir)(),
+                RUST_BACKTRACE: '1',
+            },
+        }, (error, stdout, stderr) => {
+            // Ignore errors if the process was intentionally killed
+            if (error && !isKilled && !hasResolved) {
+                console.error('\x1b[31m❌ Crypto service failed to start:\x1b[0m');
+                console.error('\x1b[31mError details:\x1b[0m', error.message);
+                // Check for specific Rust panic errors
+                if (stderr &&
+                    stderr.includes('Cannot drop a runtime in a context where blocking is not allowed')) {
+                    console.error('\x1b[31m\n🔧 This appears to be a Rust/tokio runtime issue in the crypto service binary.\x1b[0m');
+                    console.error('\x1b[31mPossible solutions:\x1b[0m');
+                    console.error('\x1b[31m1. The binary may be corrupted - try rebuilding: npm run build\x1b[0m');
+                    console.error('\x1b[31m2. There may be a compatibility issue with your system\x1b[0m');
+                    console.error('\x1b[31m3. Try running the binary directly to see more details:\x1b[0m');
+                    console.error(`\x1b[31m   ${bin}\x1b[0m`);
+                }
+                else if (stderr) {
+                    console.error('Stderr:', stderr);
+                }
+                reject(new Error(`Crypto service failed: ${error.message}`));
+                return;
+            }
+            if (stdout) {
+                // console.log('Crypto service stdout:', stdout);
+            }
+            if (stderr && !isKilled) {
+                console.error('\x1b[31mCrypto service stderr:\x1b[0m', stderr);
+            }
+        });
+        // Wait 2 seconds before resolving to ensure service is ready
+        setTimeout(() => {
+            if (!hasResolved) {
+                hasResolved = true;
+                resolve({
+                    process: cryptoProcess,
+                    kill: () => {
+                        isKilled = true;
+                        if (cryptoProcess && !cryptoProcess.killed) {
+                            cryptoProcess.kill();
+                        }
+                    },
+                });
+            }
+        }, 2000);
+    });
+}
+function getCryptoServicePath() {
+    const cryptoServiceBin = `${process.platform}-${process.arch}`;
+    let packageRoot = __dirname;
+    const binPath = path_1.default.join(packageRoot, '..', 'bin', cryptoServiceBin);
+    return binPath;
+}
+function startCryptoServiceSimple() {
+    const bin = getCryptoServicePath();
+    if (!(0, fs_1.existsSync)(bin)) {
+        console.log('\x1b[31mcrypto service not found at ' + bin + '\x1b[0m');
+        return;
+    }
+    console.log('\x1b[32mStarting crypto service at http://localhost:5050\x1b[0m');
+    (0, child_process_1.exec)(bin, { env: { SECURE_STORAGE: (0, env_1.configDir)(), RUST_BACKTRACE: '1' } }, (_, stdout, stderr) => {
+        // console.log("stdout", stdout);
+        // console.log("stderr", stderr);
+    });
+}
+function ensureWalletDirectory(chainName) {
+    const config = (0, env_1.configDir)();
+    const walletPath = path_1.default.join(config, 'wallet', chainName);
+    if (!(0, fs_1.existsSync)(walletPath)) {
+        (0, fs_1.mkdirSync)(walletPath, {
+            recursive: true,
+        });
+    }
+    return walletPath;
+}
+async function withCryptoService(operation) {
+    let cryptoService = null;
+    let startedCryptoService = false;
+    try {
+        // Start crypto service (this will check ports and reuse if available)
+        try {
+            cryptoService = await startCryptoService();
+            startedCryptoService = true;
+        }
+        catch (error) {
+            console.error('\x1b[31m❌ Failed to start crypto service:\x1b[0m');
+            console.error('\x1b[31mThis might be due to:\x1b[0m');
+            console.error('\x1b[31m- Missing or corrupted binary files\x1b[0m');
+            console.error('\x1b[31m- Insufficient permissions\x1b[0m');
+            console.error('\x1b[31m- System compatibility issues\x1b[0m');
+            console.error('\x1b[31m- Port conflicts\x1b[0m');
+            console.error('\x1b[31m\nTry running: npm run build\x1b[0m');
+            throw error;
+        }
+        const cryptoServiceClient = new CryptoService_1.CryptoService();
+        // console.log('Crypto service client created');
+        return await operation(cryptoServiceClient);
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        if (startedCryptoService && cryptoService) {
+            cryptoService.kill();
+        }
+    }
+}

package/dist/util/metadata.js

@@ -42,7 +42,7 @@ function loadMetadata(projectPath = '.') {
     try {
         const filePath = path.join(projectPath, 'metadata.json');
         if (!fs.existsSync(filePath)) {
-            console.log('Please run this command in Project directory');
+            console.log('\x1b[33mPlease run this command in Project directory\x1b[0m');
             return null;
         }
         const raw = fs.readFileSync(filePath, 'utf8');
@@ -50,7 +50,7 @@ function loadMetadata(projectPath = '.') {
         return data;
     }
     catch (err) {
-        console.log('Please run this command in Project directory');
+        console.log('\x1b[33mPlease run this command in Project directory\x1b[0m');
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.11.4",
+  "version": "0.13.0",
   "description": "airmoney-cli is a command-line interface tool designed to facilitate the development and management of decentralized applications (DApps) for Airmoney.",
   "publishConfig": {
     "access": "public"
@@ -10,8 +10,8 @@
   },
   "scripts": {
     "format": "prettier --write \"src/**/*\"",
-    "start": "npm run update-version &&npm run build && node dist/index.js",
-    "build": "npm run update-version && rm -rf dist && tsc && cp -r bin/ dist/bin/ && chmod -R +x dist",
+    "dev": "npm run build && node dist/index.js",
+    "build": "npm run update-version && rm -rf dist && tsc && cp -r src/bin dist/bin && chmod -R +x dist",
     "release": "npm run build && npm publish",
     "version": "changeset version",
     "changeset": "changeset",
@@ -67,8 +67,5 @@
     "prettier": "^3.6.1",
     "typescript": "^5.0.4"
   },
-  "packageManager": "npm@>=10.9.3 <11",
-  "engines": {
-    "node": ">=22.19.0 <23"
-  }
+  "packageManager": "npm@>=10.9.3 <11"
 }