@airmoney-degn/airmoney-cli 0.11.3 → 0.12.2

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
@@ -154,16 +119,5 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
         console.log(`Starting airmoney service server at ${url}`);
     });
     ////////////////////////////////////////////////////////////////
-    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.3"
+    "version": "0.12.2"
 }

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,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+function startCryptoService() {
+    return new Promise((resolve, reject) => {
+        const bin = getCryptoServicePath();
+        if (!(0, fs_1.existsSync)(bin)) {
+            reject(new Error(`Crypto service binary not found: ${bin}`));
+            return;
+        }
+        // console.log('Starting crypto service...');
+        let isKilled = 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) {
+                console.error('Crypto service error:', error);
+                reject(error);
+                return;
+            }
+            // if (stdout) {
+            //   console.log('Crypto service stdout:', stdout);
+            // }
+            if (stderr) {
+                console.error('Crypto service stderr:', stderr);
+            }
+        });
+        // Wait 2 seconds before resolving to ensure service is ready
+        setTimeout(() => {
+            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('crypto service not found at ' + bin);
+        return;
+    }
+    console.log('execing crypto service at http://localhost:5050');
+    (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 {
+        cryptoService = await startCryptoService();
+        startedCryptoService = true;
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.11.3",
+  "version": "0.12.2",
   "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"
 }