@btc-vision/cli 1.0.0

package/build/commands/InitCommand.js

@@ -0,0 +1,336 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { input, select, confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { validatePluginName } from '../lib/manifest.js';
+export class InitCommand extends BaseCommand {
+    constructor() {
+        super('init', 'Initialize a new OPNet plugin project');
+    }
+    configure() {
+        this.command
+            .argument('[name]', 'Plugin name')
+            .option('-t, --template <type>', 'Template type (standalone, library)', 'standalone')
+            .option('-y, --yes', 'Skip prompts and use defaults')
+            .option('--force', 'Overwrite existing files')
+            .action((name, options) => this.execute(name, options));
+    }
+    async execute(name, options) {
+        try {
+            const config = await this.gatherConfig(name, options);
+            await this.createProject(config, options?.force);
+            this.logger.success('Plugin initialized successfully!');
+            this.logger.log('');
+            this.logger.log('Next steps:');
+            this.logger.log('  1. npm install');
+            this.logger.log('  2. Edit src/index.ts');
+            this.logger.log('  3. npm run build');
+            this.logger.log('  4. opnet compile');
+            this.logger.log('');
+        }
+        catch (error) {
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Initialization cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    async gatherConfig(name, options) {
+        if (options?.yes && name) {
+            return {
+                pluginName: name,
+                authorName: 'Author',
+                pluginType: options.template || 'standalone',
+            };
+        }
+        this.logger.info('\nOPNet Plugin Initialization\n');
+        const pluginName = name || await input({
+            message: 'Plugin name:',
+            default: path.basename(process.cwd()),
+            validate: (value) => {
+                const errors = validatePluginName(value);
+                return errors.length > 0 ? errors[0] : true;
+            },
+        });
+        const description = await input({ message: 'Description:', default: '' }) || undefined;
+        const authorName = await input({ message: 'Author name:', default: process.env.USER || 'Author' });
+        const authorEmail = await input({ message: 'Author email (optional):', default: '' }) || undefined;
+        const pluginType = await select({
+            message: 'Plugin type:',
+            choices: [
+                { name: 'Standalone', value: 'standalone', description: 'Independent plugin' },
+                { name: 'Library', value: 'library', description: 'Shared library' },
+            ],
+            default: options?.template || 'standalone',
+        });
+        return { pluginName, authorName, authorEmail, description, pluginType };
+    }
+    async createProject(config, force) {
+        const nameErrors = validatePluginName(config.pluginName);
+        if (nameErrors.length > 0) {
+            this.exitWithError(`Invalid plugin name: ${nameErrors.join(', ')}`);
+        }
+        const projectDir = process.cwd();
+        const pluginJsonPath = path.join(projectDir, 'plugin.json');
+        if (fs.existsSync(pluginJsonPath) && !force) {
+            const overwrite = await confirm({ message: 'plugin.json exists. Overwrite?', default: false });
+            if (!overwrite) {
+                this.logger.warn('Initialization cancelled.');
+                return;
+            }
+        }
+        this.logger.info('Creating project structure...');
+        for (const dir of ['src', 'dist', 'build', 'test']) {
+            const dirPath = path.join(projectDir, dir);
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        this.createPluginJson(projectDir, config);
+        this.logger.success('  Created plugin.json');
+        this.createPackageJson(projectDir, config, force);
+        this.createTsConfig(projectDir, force);
+        this.createEntryPoint(projectDir, config, force);
+        this.createGitignore(projectDir, force);
+        this.createReadme(projectDir, config, force);
+    }
+    createPluginJson(projectDir, config) {
+        const manifest = {
+            name: config.pluginName,
+            version: '1.0.0',
+            opnetVersion: '^1.0.0',
+            main: 'dist/index.jsc',
+            target: 'bytenode',
+            type: 'plugin',
+            checksum: '',
+            author: config.authorEmail
+                ? { name: config.authorName, email: config.authorEmail }
+                : { name: config.authorName },
+            pluginType: config.pluginType,
+            permissions: {
+                database: {
+                    enabled: false,
+                    collections: [],
+                },
+                blocks: {
+                    preProcess: false,
+                    postProcess: false,
+                    onChange: false,
+                },
+                epochs: {
+                    onChange: false,
+                    onFinalized: false,
+                },
+                mempool: {
+                    txFeed: false,
+                    txSubmit: false,
+                },
+                api: {
+                    addEndpoints: false,
+                    addWebsocket: false,
+                },
+                threading: {
+                    maxWorkers: 1,
+                    maxMemoryMB: 256,
+                },
+                filesystem: {
+                    configDir: false,
+                    tempDir: false,
+                },
+                blockchain: {
+                    blocks: false,
+                    transactions: false,
+                    contracts: false,
+                    utxos: false,
+                },
+            },
+            resources: {
+                memory: {
+                    maxHeapMB: 256,
+                    maxOldGenMB: 128,
+                    maxYoungGenMB: 64,
+                },
+                cpu: {
+                    maxThreads: 2,
+                    priority: 'normal',
+                },
+                timeout: {
+                    initMs: 30000,
+                    hookMs: 5000,
+                    shutdownMs: 10000,
+                },
+            },
+            lifecycle: {
+                loadPriority: 100,
+                enabledByDefault: true,
+                requiresRestart: false,
+            },
+            dependencies: {},
+        };
+        if (config.description) {
+            manifest.description = config.description;
+        }
+        fs.writeFileSync(path.join(projectDir, 'plugin.json'), JSON.stringify(manifest, null, 4));
+    }
+    createPackageJson(projectDir, config, force) {
+        const packageJsonPath = path.join(projectDir, 'package.json');
+        if (fs.existsSync(packageJsonPath) && !force)
+            return;
+        const packageJson = {
+            name: config.pluginName,
+            version: '1.0.0',
+            description: config.description || 'OPNet plugin',
+            type: 'module',
+            main: 'dist/index.js',
+            scripts: {
+                build: 'tsc',
+                compile: 'opnet compile',
+                verify: 'opnet verify',
+                lint: 'eslint src/',
+            },
+            author: config.authorEmail ? `${config.authorName} <${config.authorEmail}>` : config.authorName,
+            license: 'Apache-2.0',
+            dependencies: { '@btc-vision/plugin-sdk': '^1.0.0' },
+            devDependencies: { '@types/node': '^22.0.0', typescript: '^5.8.0', '@btc-vision/cli': '^1.0.0' },
+        };
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 4));
+        this.logger.success('  Created package.json');
+    }
+    createTsConfig(projectDir, force) {
+        const tsconfigPath = path.join(projectDir, 'tsconfig.json');
+        if (fs.existsSync(tsconfigPath) && !force)
+            return;
+        const tsconfig = {
+            compilerOptions: {
+                target: 'ES2022',
+                module: 'NodeNext',
+                moduleResolution: 'NodeNext',
+                lib: ['ES2022'],
+                outDir: './dist',
+                rootDir: './src',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                declaration: true,
+                sourceMap: true,
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist', 'build'],
+        };
+        fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 4));
+        this.logger.success('  Created tsconfig.json');
+    }
+    createEntryPoint(projectDir, config, force) {
+        const indexPath = path.join(projectDir, 'src', 'index.ts');
+        if (fs.existsSync(indexPath) && !force)
+            return;
+        const className = this.toPascalCase(config.pluginName);
+        const content = config.pluginType === 'standalone'
+            ? `import { PluginBase, IPluginContext } from '@btc-vision/plugin-sdk';
+
+/**
+ * ${className} Plugin
+ *
+ * Extend PluginBase and override only the hooks you need.
+ * See the plugin-sdk documentation for available hooks.
+ */
+export default class ${className}Plugin extends PluginBase {
+    /**
+     * Called when the plugin is loaded.
+     * Always call super.onLoad(context) first to initialize this.context.
+     */
+    public async onLoad(context: IPluginContext): Promise<void> {
+        await super.onLoad(context);
+        this.context.logger.info('${className} plugin loaded');
+    }
+
+    /**
+     * Called when the plugin is being unloaded.
+     * Clean up any resources here.
+     */
+    public async onUnload(): Promise<void> {
+        this.context.logger.info('${className} plugin unloading');
+    }
+
+    /**
+     * Called when the plugin is enabled.
+     */
+    public async onEnable(): Promise<void> {
+        this.context.logger.info('${className} plugin enabled');
+    }
+
+    /**
+     * Called when the plugin is disabled.
+     */
+    public async onDisable(): Promise<void> {
+        this.context.logger.info('${className} plugin disabled');
+    }
+}
+`
+            : `export * from './lib/index.js';
+`;
+        fs.writeFileSync(indexPath, content);
+        this.logger.success('  Created src/index.ts');
+        if (config.pluginType === 'library') {
+            const libDir = path.join(projectDir, 'src', 'lib');
+            fs.mkdirSync(libDir, { recursive: true });
+            fs.writeFileSync(path.join(libDir, 'index.ts'), `export function hello(): string {
+    return 'Hello from ${config.pluginName}!';
+}
+`);
+            this.logger.success('  Created src/lib/index.ts');
+        }
+    }
+    createGitignore(projectDir, force) {
+        const gitignorePath = path.join(projectDir, '.gitignore');
+        if (fs.existsSync(gitignorePath) && !force)
+            return;
+        fs.writeFileSync(gitignorePath, `node_modules/
+dist/
+build/
+*.jsc
+*.opnet
+.idea/
+.vscode/
+.DS_Store
+.env
+*.log
+coverage/
+`);
+        this.logger.success('  Created .gitignore');
+    }
+    createReadme(projectDir, config, force) {
+        const readmePath = path.join(projectDir, 'README.md');
+        if (fs.existsSync(readmePath) && !force)
+            return;
+        fs.writeFileSync(readmePath, `# ${config.pluginName}
+
+${config.description || `An OPNet ${config.pluginType} plugin.`}
+
+## Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm run build    # Build TypeScript
+npm run compile  # Compile to .opnet
+npm run verify   # Verify binary
+\`\`\`
+
+## License
+
+Apache-2.0
+`);
+        this.logger.success('  Created README.md');
+    }
+    toPascalCase(str) {
+        return str.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+    }
+}
+export const initCommand = new InitCommand().getCommand();

package/build/commands/InstallCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class InstallCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const installCommand: import("commander").Command;

package/build/commands/InstallCommand.js

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getVersion, registryToMldsaLevel } from '../lib/registry.js';
+import { fetchFromIPFS, isValidCid } from '../lib/ipfs.js';
+import { parseOpnetBinary, verifyChecksum, formatFileSize } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class InstallCommand extends BaseCommand {
+    constructor() {
+        super('install', 'Download and verify a plugin from the registry');
+    }
+    configure() {
+        this.command
+            .argument('<package>', 'Package name[@version] or IPFS CID')
+            .option('-o, --output <path>', 'Output directory (default: ./plugins/)')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('--skip-verify', 'Skip signature verification')
+            .action((packageInput, options) => this.execute(packageInput, options || { network: 'mainnet' }));
+    }
+    async execute(packageInput, options) {
+        try {
+            let cid;
+            let packageName;
+            let version;
+            if (isValidCid(packageInput)) {
+                cid = packageInput;
+                packageName = 'unknown';
+                version = 'unknown';
+                this.logger.info(`Installing from CID: ${cid}`);
+            }
+            else {
+                const atIndex = packageInput.lastIndexOf('@');
+                if (atIndex > 0 && !packageInput.startsWith('@')) {
+                    packageName = packageInput.substring(0, atIndex);
+                    version = packageInput.substring(atIndex + 1);
+                }
+                else if (packageInput.startsWith('@') && packageInput.indexOf('@', 1) > 0) {
+                    const secondAt = packageInput.indexOf('@', 1);
+                    packageName = packageInput.substring(0, secondAt);
+                    version = packageInput.substring(secondAt + 1);
+                }
+                else {
+                    packageName = packageInput;
+                    version = 'latest';
+                }
+                this.logger.info(`Fetching ${packageName}...`);
+                const network = (options?.network || 'mainnet');
+                const packageInfo = await getPackage(packageName, network);
+                if (!packageInfo) {
+                    this.logger.fail('Package not found');
+                    this.logger.error(`Package "${packageName}" does not exist.`);
+                    process.exit(1);
+                }
+                if (version === 'latest') {
+                    version = packageInfo.latestVersion;
+                }
+                const versionInfo = await getVersion(packageName, version, network);
+                if (!versionInfo) {
+                    this.logger.fail('Version not found');
+                    this.logger.error(`Version "${version}" does not exist.`);
+                    process.exit(1);
+                }
+                if (versionInfo.deprecated) {
+                    this.logger.warn(`Version ${version} is deprecated`);
+                }
+                cid = versionInfo.ipfsCid;
+                this.logger.success(`Found: ${packageName}@${version}`);
+                this.logger.log('');
+                this.logger.log(`IPFS CID:    ${cid}`);
+                this.logger.log(`MLDSA Level: ${registryToMldsaLevel(versionInfo.mldsaLevel)}`);
+                this.logger.log(`Publisher:   ${versionInfo.publisher}`);
+                this.logger.log('');
+            }
+            this.logger.info('Downloading from IPFS...');
+            const result = await fetchFromIPFS(cid);
+            this.logger.success(`Downloaded (${formatFileSize(result.size)})`);
+            this.logger.info('Verifying binary...');
+            const parsed = parseOpnetBinary(result.data);
+            if (!verifyChecksum(parsed)) {
+                this.logger.fail('Checksum verification failed');
+                this.logger.error('The binary appears to be corrupted.');
+                process.exit(1);
+            }
+            if (!options?.skipVerify) {
+                const isUnsigned = parsed.publicKey.every((b) => b === 0);
+                if (isUnsigned) {
+                    this.logger.warn('Binary is unsigned');
+                }
+                else {
+                    const actualMldsaLevel = [44, 65, 87][parsed.mldsaLevel];
+                    const signatureValid = CLIWallet.verifyMLDSA(parsed.checksum, parsed.signature, parsed.publicKey, actualMldsaLevel);
+                    if (!signatureValid) {
+                        this.logger.fail('Signature verification failed');
+                        this.logger.error('The binary signature is invalid.');
+                        process.exit(1);
+                    }
+                    this.logger.success('Signature verified');
+                }
+            }
+            else {
+                this.logger.warn('Skipping signature verification');
+            }
+            if (packageName === 'unknown') {
+                packageName = parsed.metadata.name;
+                version = parsed.metadata.version;
+            }
+            const outputDir = options?.output || path.join(process.cwd(), 'plugins');
+            fs.mkdirSync(outputDir, { recursive: true });
+            const fileName = `${packageName.replace(/^@/, '').replace(/\//g, '-')}-${version}.opnet`;
+            const outputPath = path.join(outputDir, fileName);
+            this.logger.info('Saving plugin...');
+            fs.writeFileSync(outputPath, result.data);
+            this.logger.success('Plugin installed');
+            this.logger.log('');
+            this.logger.success('Plugin installed successfully!');
+            this.logger.log('');
+            this.logger.log(`Package:  ${parsed.metadata.name}`);
+            this.logger.log(`Version:  ${parsed.metadata.version}`);
+            this.logger.log(`Type:     ${parsed.metadata.pluginType}`);
+            this.logger.log(`Size:     ${formatFileSize(result.size)}`);
+            this.logger.log(`Output:   ${outputPath}`);
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Installation failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const installCommand = new InstallCommand().getCommand();

package/build/commands/KeygenCommand.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { BaseCommand } from './BaseCommand.js';
+export declare class KeygenCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private createMnemonicCommand;
+    private createMldsaCommand;
+    private createInfoCommand;
+    private handleMnemonic;
+    private handleMldsa;
+    private handleInfo;
+}
+export declare const keygenCommand: Command;

package/build/commands/KeygenCommand.js

@@ -0,0 +1,133 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import { BaseCommand } from './BaseCommand.js';
+import { generateMLDSAKeypair, generateMnemonic, computePublicKeyHash } from '../lib/wallet.js';
+import { isValidMldsaLevel } from '../lib/credentials.js';
+export class KeygenCommand extends BaseCommand {
+    constructor() {
+        super('keygen', 'Generate cryptographic keys');
+    }
+    configure() {
+        this.command
+            .addCommand(this.createMnemonicCommand())
+            .addCommand(this.createMldsaCommand())
+            .addCommand(this.createInfoCommand());
+    }
+    createMnemonicCommand() {
+        return new Command('mnemonic')
+            .description('Generate a new BIP-39 mnemonic phrase')
+            .option('-o, --output <file>', 'Write mnemonic to file (secure permissions)')
+            .action((options) => this.handleMnemonic(options));
+    }
+    createMldsaCommand() {
+        return new Command('mldsa')
+            .description('Generate a standalone MLDSA keypair')
+            .option('-l, --level <level>', 'MLDSA security level (44, 65, 87)', '44')
+            .option('-o, --output <prefix>', 'Write keys to files with prefix')
+            .option('--json', 'Output as JSON')
+            .action((options) => {
+            this.handleMldsa(options);
+        });
+    }
+    createInfoCommand() {
+        return new Command('info')
+            .description('Show information about MLDSA key sizes')
+            .action(() => this.handleInfo());
+    }
+    handleMnemonic(options) {
+        try {
+            const mnemonic = generateMnemonic();
+            if (options.output) {
+                fs.writeFileSync(options.output, mnemonic + '\n', { mode: 0o600 });
+                this.logger.success(`Mnemonic saved to: ${options.output}`);
+                this.logger.warn('Keep this file secure and backed up!');
+            }
+            else {
+                this.logger.info('\nNew BIP-39 Mnemonic Phrase:\n');
+                this.logger.log(mnemonic);
+                this.logger.log('');
+                this.logger.warn('IMPORTANT: Write down these words and store them securely.');
+                this.logger.warn('Anyone with this phrase can access your wallet.');
+                this.logger.warn('Never share this phrase with anyone.');
+            }
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    handleMldsa(options) {
+        try {
+            const levelNum = parseInt(options.level, 10);
+            if (!isValidMldsaLevel(levelNum)) {
+                this.exitWithError(`Invalid MLDSA level: ${options.level}. Valid: 44, 65, 87`);
+                return;
+            }
+            this.logger.info(`Generating MLDSA-${levelNum} keypair...`);
+            const keypair = generateMLDSAKeypair(levelNum);
+            const publicKeyHash = computePublicKeyHash(keypair.publicKey);
+            if (options.output) {
+                const privateKeyPath = `${options.output}.private.key`;
+                const publicKeyPath = `${options.output}.public.key`;
+                fs.writeFileSync(privateKeyPath, keypair.privateKey.toString('hex') + '\n', {
+                    mode: 0o600,
+                });
+                fs.writeFileSync(publicKeyPath, keypair.publicKey.toString('hex') + '\n', {
+                    mode: 0o644,
+                });
+                this.logger.success('Keys generated successfully!');
+                this.logger.info(`  Private key: ${privateKeyPath}`);
+                this.logger.info(`  Public key:  ${publicKeyPath}`);
+                this.logger.log('');
+                this.logger.log(`Public Key Hash: ${publicKeyHash}`);
+                this.logger.log('');
+                this.logger.warn('IMPORTANT: Keep the private key secure!');
+            }
+            else if (options.json) {
+                const output = {
+                    level: levelNum,
+                    privateKey: keypair.privateKey.toString('hex'),
+                    publicKey: keypair.publicKey.toString('hex'),
+                    publicKeyHash,
+                    privateKeySize: keypair.privateKey.length,
+                    publicKeySize: keypair.publicKey.length,
+                };
+                this.logger.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                this.logger.info(`\nMLDSA-${levelNum} Keypair:\n`);
+                this.logger.log(`Public Key Hash: ${publicKeyHash}`);
+                this.logger.log(`Public Key Size: ${keypair.publicKey.length} bytes`);
+                this.logger.log(`Private Key Size: ${keypair.privateKey.length} bytes`);
+                this.logger.log('');
+                this.logger.log('Public Key (hex):');
+                this.logger.log(keypair.publicKey.toString('hex'));
+                this.logger.log('');
+                this.logger.log('Private Key (hex):');
+                this.logger.log(keypair.privateKey.toString('hex'));
+                this.logger.log('');
+                this.logger.warn('IMPORTANT: Store the private key securely!');
+                this.logger.warn('Use --output <prefix> to save to files.');
+            }
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    handleInfo() {
+        this.logger.info('\nMLDSA Key Sizes:\n');
+        this.logger.log('─'.repeat(60));
+        this.logger.log(`${'Level'.padEnd(12)}${'Public Key'.padEnd(15)}${'Private Key'.padEnd(15)}${'Signature'.padEnd(15)}`);
+        this.logger.log('─'.repeat(60));
+        this.logger.log(`${'MLDSA-44'.padEnd(12)}${'1,312 bytes'.padEnd(15)}${'2,560 bytes'.padEnd(15)}${'2,420 bytes'.padEnd(15)}`);
+        this.logger.log(`${'MLDSA-65'.padEnd(12)}${'1,952 bytes'.padEnd(15)}${'4,032 bytes'.padEnd(15)}${'3,309 bytes'.padEnd(15)}`);
+        this.logger.log(`${'MLDSA-87'.padEnd(12)}${'2,592 bytes'.padEnd(15)}${'4,896 bytes'.padEnd(15)}${'4,627 bytes'.padEnd(15)}`);
+        this.logger.log('─'.repeat(60));
+        this.logger.log('');
+        this.logger.log('Security levels:');
+        this.logger.log('  MLDSA-44: ~128-bit security (fastest, smallest)');
+        this.logger.log('  MLDSA-65: ~192-bit security (balanced)');
+        this.logger.log('  MLDSA-87: ~256-bit security (highest security)');
+        this.logger.log('');
+    }
+}
+export const keygenCommand = new KeygenCommand().getCommand();

package/build/commands/ListCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class ListCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const listCommand: import("commander").Command;