@btc-vision/cli 1.0.0

package/build/commands/SignCommand.js

@@ -0,0 +1,80 @@
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, buildOpnetBinary, computeChecksum, formatFileSize } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+export class SignCommand extends BaseCommand {
+    constructor() {
+        super('sign', 'Sign or re-sign a .opnet binary with your MLDSA key');
+    }
+    configure() {
+        this.command
+            .argument('<file>', 'Path to .opnet file')
+            .option('-o, --output <path>', 'Output file path (default: overwrites input)')
+            .option('--force', 'Force re-signing even if already signed by different key')
+            .action((file, options) => this.execute(file, options));
+    }
+    execute(file, options) {
+        try {
+            if (!fs.existsSync(file)) {
+                this.exitWithError(`File not found: ${file}`);
+            }
+            this.logger.info('Loading wallet...');
+            const credentials = loadCredentials();
+            if (!credentials || !canSign(credentials)) {
+                this.logger.fail('No credentials configured');
+                this.logger.warn('To sign plugins, run: opnet login');
+                process.exit(1);
+            }
+            const wallet = CLIWallet.fromCredentials(credentials);
+            this.logger.success(`Wallet loaded (MLDSA-${wallet.securityLevel})`);
+            this.logger.info('Parsing binary...');
+            const data = fs.readFileSync(file);
+            const parsed = parseOpnetBinary(data);
+            this.logger.success(`Parsed: ${parsed.metadata.name}@${parsed.metadata.version}`);
+            const isUnsigned = parsed.publicKey.every((b) => b === 0);
+            const currentPkHash = crypto.createHash('sha256').update(parsed.publicKey).digest('hex');
+            const newPkHash = wallet.mldsaPublicKeyHash;
+            if (!isUnsigned && currentPkHash !== newPkHash && !options.force) {
+                this.logger.log('');
+                this.logger.warn('Warning: This binary is already signed by a different key.');
+                this.logger.log(`  Current signer: ${currentPkHash.substring(0, 32)}...`);
+                this.logger.log(`  Your key:       ${newPkHash.substring(0, 32)}...`);
+                this.logger.log('');
+                this.logger.log('Use --force to re-sign with your key.');
+                process.exit(1);
+            }
+            this.logger.info('Signing...');
+            const metadataBytes = Buffer.from(parsed.rawMetadata, 'utf-8');
+            const checksum = computeChecksum(metadataBytes, parsed.bytecode, parsed.proto ?? Buffer.alloc(0));
+            const signature = wallet.signMLDSA(checksum);
+            this.logger.success(`Signed (${formatFileSize(signature.length)} signature)`);
+            this.logger.info('Rebuilding binary...');
+            const newBinary = buildOpnetBinary({
+                mldsaLevel: wallet.securityLevel,
+                publicKey: wallet.mldsaPublicKey,
+                signature,
+                metadata: parsed.metadata,
+                bytecode: parsed.bytecode,
+                proto: parsed.proto ?? Buffer.alloc(0),
+            });
+            this.logger.success(`Binary rebuilt (${formatFileSize(newBinary.length)})`);
+            const outputPath = options.output || file;
+            fs.writeFileSync(outputPath, newBinary);
+            this.logger.log('');
+            this.logger.success('Plugin signed successfully!');
+            this.logger.log('');
+            this.logger.log(`Output:       ${outputPath}`);
+            this.logger.log(`Plugin:       ${parsed.metadata.name}@${parsed.metadata.version}`);
+            this.logger.log(`MLDSA Level:  ${wallet.securityLevel}`);
+            this.logger.log(`Publisher:    ${newPkHash.substring(0, 32)}...`);
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Signing failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const signCommand = new SignCommand().getCommand();

package/build/commands/TransferCommand.d.ts

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

package/build/commands/TransferCommand.js

@@ -0,0 +1,179 @@
+import { input, confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getScope, getPendingTransfer, getPendingScopeTransfer, } from '../lib/registry.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class TransferCommand extends BaseCommand {
+    constructor() {
+        super('transfer', 'Initiate ownership transfer of a package or scope');
+    }
+    configure() {
+        this.command
+            .argument('<name>', 'Package name or @scope')
+            .argument('[newOwner]', 'New owner address')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .option('--cancel', 'Cancel pending transfer')
+            .action((name, newOwner, options) => this.execute(name, newOwner, options || { network: 'mainnet' }));
+    }
+    async execute(name, newOwner, options) {
+        try {
+            this.logger.info('Loading wallet...');
+            const credentials = loadCredentials();
+            if (!credentials || !canSign(credentials)) {
+                this.logger.fail('No credentials configured');
+                this.logger.warn('Run `opnet login` to configure your wallet.');
+                process.exit(1);
+            }
+            CLIWallet.fromCredentials(credentials);
+            this.logger.success('Wallet loaded');
+            const network = (options?.network || 'mainnet');
+            const isScope = name.startsWith('@') && !name.includes('/');
+            const displayName = isScope ? name : `package ${name}`;
+            if (options?.cancel) {
+                await this.handleCancel(name, isScope, network, options);
+                return;
+            }
+            let targetOwner = newOwner;
+            if (!targetOwner) {
+                targetOwner = await input({
+                    message: 'New owner address:',
+                    validate: (value) => {
+                        if (!value || value.length < 20) {
+                            return 'Please enter a valid address';
+                        }
+                        return true;
+                    },
+                });
+            }
+            this.logger.info(`Checking ${displayName}...`);
+            if (isScope) {
+                const scopeName = name.substring(1);
+                const scopeInfo = await getScope(scopeName, network);
+                if (!scopeInfo) {
+                    this.logger.fail('Scope not found');
+                    this.logger.error(`Scope "${name}" does not exist.`);
+                    process.exit(1);
+                }
+                this.logger.success(`Found scope ${name}`);
+            }
+            else {
+                const packageInfo = await getPackage(name, network);
+                if (!packageInfo) {
+                    this.logger.fail('Package not found');
+                    this.logger.error(`Package "${name}" does not exist.`);
+                    process.exit(1);
+                }
+                this.logger.success(`Found package ${name}`);
+            }
+            this.logger.log('');
+            this.logger.info('Transfer Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Type:       ${isScope ? 'Scope' : 'Package'}`);
+            this.logger.log(`Name:       ${name}`);
+            this.logger.log(`New Owner: ${targetOwner}`);
+            this.logger.log(`Network:    ${options?.network}`);
+            this.logger.log('');
+            this.logger.warn('Note: The new owner must call `opnet accept` to complete the transfer.');
+            this.logger.log('');
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Initiate transfer of ${displayName}?`,
+                    default: false,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Transfer cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Initiating transfer...');
+            if (isScope) {
+                const scopeName = name.substring(1);
+                this.logger.warn('Transfer transaction required.');
+                this.logger.log('Transaction would call: initiateScopeTransfer(');
+                this.logger.log(`  scopeName: "${scopeName}",`);
+                this.logger.log(`  newOwner: "${targetOwner}"`);
+                this.logger.log(')');
+            }
+            else {
+                this.logger.warn('Transfer transaction required.');
+                this.logger.log('Transaction would call: initiateTransfer(');
+                this.logger.log(`  packageName: "${name}",`);
+                this.logger.log(`  newOwner: "${targetOwner}"`);
+                this.logger.log(')');
+            }
+            this.logger.info('Transfer (transaction pending)');
+            this.logger.log('');
+            this.logger.success('Transfer initiated!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Transfer failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Transfer cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    async handleCancel(name, isScope, network, options) {
+        this.logger.info('Checking pending transfer...');
+        if (isScope) {
+            const scopeName = name.substring(1);
+            const pending = await getPendingScopeTransfer(scopeName, network);
+            if (!pending) {
+                this.logger.warn('No pending transfer');
+                this.logger.log(`No pending transfer for ${name}.`);
+                return;
+            }
+            this.logger.success(`Found pending transfer to ${pending.pendingOwner}`);
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Cancel ownership transfer of ${name}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Cancelling transfer...');
+            this.logger.warn('Cancellation transaction required.');
+            this.logger.log('Transaction would call: cancelScopeTransfer(');
+            this.logger.log(`  scopeName: "${scopeName}"`);
+            this.logger.log(')');
+            this.logger.info('Cancellation (transaction pending)');
+        }
+        else {
+            const pending = await getPendingTransfer(name, network);
+            if (!pending) {
+                this.logger.warn('No pending transfer');
+                this.logger.log(`No pending transfer for ${name}.`);
+                return;
+            }
+            this.logger.success(`Found pending transfer to ${pending.pendingOwner}`);
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Cancel ownership transfer of ${name}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Cancelling transfer...');
+            this.logger.warn('Cancellation transaction required.');
+            this.logger.log('Transaction would call: cancelTransfer(');
+            this.logger.log(`  packageName: "${name}"`);
+            this.logger.log(')');
+            this.logger.info('Cancellation (transaction pending)');
+        }
+        this.logger.log('');
+        this.logger.success('Transfer cancellation submitted!');
+        this.logger.warn('Note: Registry transaction support is coming soon.');
+        this.logger.log('');
+    }
+}
+export const transferCommand = new TransferCommand().getCommand();

package/build/commands/UndeprecateCommand.d.ts

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

package/build/commands/UndeprecateCommand.js

@@ -0,0 +1,95 @@
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getPackage, getVersion, isVersionImmutable } from '../lib/registry.js';
+import { loadCredentials, canSign } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class UndeprecateCommand extends BaseCommand {
+    constructor() {
+        super('undeprecate', 'Remove deprecation from a package version');
+    }
+    configure() {
+        this.command
+            .argument('<package>', 'Package name (e.g., @scope/name or name)')
+            .argument('<version>', 'Version to undeprecate')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((packageName, version, options) => this.execute(packageName, version, options || { network: 'mainnet' }));
+    }
+    async execute(packageName, version, options) {
+        try {
+            this.logger.info('Loading wallet...');
+            const credentials = loadCredentials();
+            if (!credentials || !canSign(credentials)) {
+                this.logger.fail('No credentials configured');
+                this.logger.warn('Run `opnet login` to configure your wallet.');
+                process.exit(1);
+            }
+            CLIWallet.fromCredentials(credentials);
+            this.logger.success('Wallet loaded');
+            this.logger.info('Fetching package info...');
+            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);
+            }
+            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('Not deprecated');
+                this.logger.log(`Version ${version} is not deprecated.`);
+                return;
+            }
+            const immutable = await isVersionImmutable(packageName, version, network);
+            if (immutable) {
+                this.logger.fail('Version is immutable');
+                this.logger.error('This version is past the 72-hour mutability window.');
+                this.logger.error('Immutable versions cannot be undeprecated.');
+                process.exit(1);
+            }
+            this.logger.success(`Found: ${packageName}@${version} (deprecated)`);
+            this.logger.log('');
+            this.logger.info('Undeprecation Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Package:  ${packageName}`);
+            this.logger.log(`Version:  ${version}`);
+            this.logger.log(`Network:  ${options?.network}`);
+            this.logger.log('');
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Remove deprecation from ${packageName}@${version}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Undeprecation cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Removing deprecation...');
+            this.logger.warn('Undeprecation transaction required.');
+            this.logger.log('Transaction would call: undeprecateVersion(');
+            this.logger.log(`  packageName: "${packageName}",`);
+            this.logger.log(`  version: "${version}"`);
+            this.logger.log(')');
+            this.logger.info('Undeprecation (transaction pending)');
+            this.logger.log('');
+            this.logger.success('Undeprecation submitted!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Undeprecation failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Undeprecation cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const undeprecateCommand = new UndeprecateCommand().getCommand();

package/build/commands/UpdateCommand.d.ts

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

package/build/commands/UpdateCommand.js

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, verifyChecksum } from '../lib/binary.js';
+import { getPackage, getVersion } from '../lib/registry.js';
+import { fetchFromIPFS } from '../lib/ipfs.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class UpdateCommand extends BaseCommand {
+    constructor() {
+        super('update', 'Update installed plugins to latest versions');
+    }
+    configure() {
+        this.command
+            .argument('[package]', 'Specific package to update (default: all)')
+            .option('-d, --dir <path>', 'Plugins directory (default: ./plugins/)')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('--skip-verify', 'Skip signature verification')
+            .action((packageName, options) => this.execute(packageName, options || { network: 'mainnet' }));
+    }
+    async execute(packageName, options) {
+        try {
+            const pluginsDir = options?.dir || path.join(process.cwd(), 'plugins');
+            if (!fs.existsSync(pluginsDir)) {
+                this.logger.warn('No plugins directory found.');
+                this.logger.log(`Expected: ${pluginsDir}`);
+                return;
+            }
+            const files = fs.readdirSync(pluginsDir).filter((f) => f.endsWith('.opnet'));
+            if (files.length === 0) {
+                this.logger.warn('No plugins installed.');
+                return;
+            }
+            const network = (options?.network || 'mainnet');
+            const updates = [];
+            this.logger.info('\nChecking for updates...\n');
+            for (const file of files) {
+                const filePath = path.join(pluginsDir, file);
+                try {
+                    const data = fs.readFileSync(filePath);
+                    const parsed = parseOpnetBinary(data);
+                    const name = parsed.metadata.name;
+                    if (packageName && name !== packageName) {
+                        continue;
+                    }
+                    this.logger.info(`Checking ${name}...`);
+                    const packageInfo = await getPackage(name, network);
+                    if (!packageInfo) {
+                        this.logger.info(`${name}: not found in registry`);
+                        continue;
+                    }
+                    const currentVersion = parsed.metadata.version;
+                    const latestVersion = packageInfo.latestVersion;
+                    if (currentVersion === latestVersion) {
+                        this.logger.success(`${name}@${currentVersion}: up to date`);
+                        continue;
+                    }
+                    const versionInfo = await getVersion(name, latestVersion, network);
+                    if (!versionInfo) {
+                        this.logger.warn(`${name}: latest version info unavailable`);
+                        continue;
+                    }
+                    this.logger.info(`${name}: ${currentVersion} -> ${latestVersion}`);
+                    updates.push({
+                        file,
+                        name,
+                        currentVersion,
+                        latestVersion,
+                        cid: versionInfo.ipfsCid,
+                    });
+                }
+                catch {
+                    this.logger.warn(`${file}: failed to parse`);
+                }
+            }
+            if (updates.length === 0) {
+                this.logger.log('');
+                this.logger.success('All plugins are up to date!');
+                return;
+            }
+            this.logger.log('');
+            this.logger.info('Available Updates:');
+            this.logger.log('─'.repeat(60));
+            for (const update of updates) {
+                this.logger.log(`  ${update.name}: ${update.currentVersion} -> ${update.latestVersion}`);
+            }
+            this.logger.log('');
+            for (const update of updates) {
+                this.logger.info(`Updating ${update.name}...`);
+                try {
+                    const result = await fetchFromIPFS(update.cid);
+                    const parsed = parseOpnetBinary(result.data);
+                    if (!verifyChecksum(parsed)) {
+                        this.logger.fail(`${update.name}: checksum failed`);
+                        continue;
+                    }
+                    if (!options?.skipVerify) {
+                        const isUnsigned = parsed.publicKey.every((b) => b === 0);
+                        if (!isUnsigned) {
+                            const mldsaLevel = [44, 65, 87][parsed.mldsaLevel];
+                            const signatureValid = CLIWallet.verifyMLDSA(parsed.checksum, parsed.signature, parsed.publicKey, mldsaLevel);
+                            if (!signatureValid) {
+                                this.logger.fail(`${update.name}: signature invalid`);
+                                continue;
+                            }
+                        }
+                    }
+                    const newFileName = `${update.name.replace(/^@/, '').replace(/\//g, '-')}-${update.latestVersion}.opnet`;
+                    const newFilePath = path.join(pluginsDir, newFileName);
+                    fs.writeFileSync(newFilePath, result.data);
+                    const oldFilePath = path.join(pluginsDir, update.file);
+                    if (oldFilePath !== newFilePath && fs.existsSync(oldFilePath)) {
+                        fs.unlinkSync(oldFilePath);
+                    }
+                    this.logger.success(`${update.name}: updated to ${update.latestVersion}`);
+                }
+                catch (error) {
+                    this.logger.fail(`${update.name}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            this.logger.log('');
+            this.logger.success('Update complete!');
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Update failed');
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const updateCommand = new UpdateCommand().getCommand();

package/build/commands/VerifyCommand.d.ts

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