@btc-vision/cli 1.0.1 → 1.0.3

package/src/commands/ConfigCommand.ts

@@ -8,8 +8,7 @@ import { Command } from 'commander';
 import * as os from 'os';
 import * as path from 'path';
 import { BaseCommand } from './BaseCommand.js';
-import { displayConfig, getConfigValue, saveConfig, setConfigValue } from '../lib/config.js';
-import { CLIConfig } from '../types/index.js';
+import { DEFAULT_CONFIG, displayConfig, getConfigValue, saveConfig, setConfigValue, } from '../lib/config.js';
 
 export class ConfigCommand extends BaseCommand {
     constructor() {
@@ -106,33 +105,7 @@ export class ConfigCommand extends BaseCommand {
             return;
         }
 
-        const defaultConfig: CLIConfig = {
-            defaultNetwork: 'mainnet',
-            rpcUrls: {
-                mainnet: 'https://api.opnet.org',
-                testnet: 'https://testnet.opnet.org',
-                regtest: 'http://localhost:9001',
-            },
-            ipfsGateway: 'https://ipfs.opnet.org/ipfs/',
-            ipfsGateways: [
-                'https://ipfs.opnet.org/ipfs/',
-                'https://ipfs.io/ipfs/',
-                'https://cloudflare-ipfs.com/ipfs/',
-                'https://dweb.link/ipfs/',
-            ],
-            ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
-            ipfsPinningApiKey: '',
-            ipfsPinningAuthHeader: 'Authorization',
-            registryAddresses: {
-                mainnet: '',
-                testnet: '',
-                regtest: '',
-            },
-            defaultMldsaLevel: 44,
-            indexerUrl: 'https://indexer.opnet.org',
-        };
-
-        saveConfig(defaultConfig);
+        saveConfig(DEFAULT_CONFIG);
         this.logger.success('Configuration reset to defaults.');
     }
 

package/src/commands/DeprecateCommand.ts

@@ -6,9 +6,15 @@
 
 import { confirm, input } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getVersion, isVersionImmutable } from '../lib/registry.js';
+import { getPackage, getRegistryContract, getVersion, isVersionImmutable } from '../lib/registry.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 import { CLIWallet } from '../lib/wallet.js';
+import {
+    buildTransactionParams,
+    checkBalance,
+    formatSats,
+    getWalletAddress,
+} from '../lib/transaction.js';
 import { NetworkName } from '../types/index.js';
 
 interface DeprecateOptions {
@@ -48,7 +54,7 @@ export class DeprecateCommand extends BaseCommand {
                 this.logger.warn('Run `opnet login` to configure your wallet.');
                 process.exit(1);
             }
-            CLIWallet.fromCredentials(credentials);
+            const wallet = CLIWallet.fromCredentials(credentials);
             this.logger.success('Wallet loaded');
 
             // Get package info
@@ -128,19 +134,50 @@ export class DeprecateCommand extends BaseCommand {
                 }
             }
 
+            // Check wallet balance
+            this.logger.info('Checking wallet balance...');
+            const { sufficient, balance } = await checkBalance(wallet, network);
+            if (!sufficient) {
+                this.logger.fail('Insufficient balance');
+                this.logger.error(`Wallet balance: ${formatSats(balance)}`);
+                this.logger.error('Please fund your wallet before deprecating.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             // Execute deprecation
             this.logger.info('Deprecating version...');
-            this.logger.warn('Deprecation transaction required.');
-            this.logger.log('Transaction would call: deprecateVersion(');
-            this.logger.log(`  packageName: "${packageName}",`);
-            this.logger.log(`  version: "${targetVersion}",`);
-            this.logger.log(`  reason: "${message}"`);
-            this.logger.log(')');
-            this.logger.info('Deprecation (transaction pending)');
 
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const deprecateResult = await contract.deprecateVersion(
+                packageName,
+                targetVersion,
+                message,
+            );
+
+            if (deprecateResult.revert) {
+                this.logger.fail('Deprecation would fail');
+                this.logger.error(`Reason: ${deprecateResult.revert}`);
+                process.exit(1);
+            }
+
+            if (deprecateResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${deprecateResult.estimatedGas} sats`);
+            }
+
+            const receipt = await deprecateResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Version deprecated successfully!');
             this.logger.log('');
-            this.logger.success('Deprecation submitted!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log(`Package:        ${packageName}`);
+            this.logger.log(`Version:        ${targetVersion}`);
+            this.logger.log(`Reason:         ${message}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
             this.logger.log('');
         } catch (error) {
             this.logger.fail('Deprecation failed');

package/src/commands/InitCommand.ts

@@ -185,7 +185,7 @@ export class InitCommand extends BaseCommand {
         const manifest: Record<string, unknown> = {
             name: config.pluginName,
             version: '1.0.0',
-            opnetVersion: '^1.0.0',
+            opnetVersion: '>=0.0.1',
             main: 'dist/index.jsc',
             target: 'bytenode',
             type: 'plugin',
@@ -223,12 +223,6 @@ export class InitCommand extends BaseCommand {
                     configDir: false,
                     tempDir: false,
                 },
-                blockchain: {
-                    blocks: false,
-                    transactions: false,
-                    contracts: false,
-                    utxos: false,
-                },
             },
             resources: {
                 memory: {

package/src/commands/PublishCommand.ts

@@ -17,12 +17,24 @@ import {
     computePermissionsHash,
     encodeDependencies,
     getPackage,
+    getRegistryContract,
     getScope,
     mldsaLevelToRegistry,
     parsePackageName,
     pluginTypeToRegistry,
 } from '../lib/registry.js';
+import {
+    buildTransactionParams,
+    checkBalance,
+    DEFAULT_FEE_RATE,
+    DEFAULT_MAX_SAT_TO_SPEND,
+    formatSats,
+    getWalletAddress,
+    waitForTransactionConfirmation,
+} from '../lib/transaction.js';
 import { CLIMldsaLevel, NetworkName } from '../types/index.js';
+import { PsbtOutputExtended } from '@btc-vision/bitcoin';
+import { StrippedTransactionOutput, TransactionOutputFlags } from 'opnet';
 
 interface PublishOptions {
     network: string;
@@ -116,12 +128,13 @@ export class PublishCommand extends BaseCommand {
 
             // Check registry status
             this.logger.info('Checking registry status...');
-            const { scope, name } = parsePackageName(meta.name);
+            const { scope } = parsePackageName(meta.name);
             const network = (options?.network || 'mainnet') as NetworkName;
 
             // Check if scoped package
             if (scope) {
                 const scopeInfo = await getScope(scope, network);
+
                 if (!scopeInfo) {
                     this.logger.fail(`Scope @${scope} is not registered`);
                     this.logger.warn(
@@ -180,44 +193,141 @@ export class PublishCommand extends BaseCommand {
             const permissionsHash = computePermissionsHash(meta.permissions);
             const dependencies = encodeDependencies(meta.dependencies || {});
 
+            // Check wallet balance
+            this.logger.info('Checking wallet balance...');
+            const { sufficient, balance } = await checkBalance(wallet, network);
+            if (!sufficient) {
+                this.logger.fail('Insufficient balance');
+                this.logger.error(`Wallet balance: ${formatSats(balance)}`);
+                this.logger.error('Please fund your wallet before publishing.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
+            // Get contract with sender for write operations
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+
+            const treasuryAddress = await contract.getTreasuryAddress();
+
+            const extraUtxo: PsbtOutputExtended = {
+                address: treasuryAddress.properties.treasuryAddress,
+                value: 10_000,
+            };
+
+            let txParams = buildTransactionParams(
+                wallet,
+                network,
+                DEFAULT_MAX_SAT_TO_SPEND,
+                DEFAULT_FEE_RATE,
+                extraUtxo,
+            );
+
             // Register package if new
             if (isNewPackage) {
-                this.logger.info('Registering package...');
-                this.logger.warn('Package registration required.');
-                this.logger.log(`Transaction would call: registerPackage("${meta.name}")`);
-                this.logger.info('Package registration (transaction pending)');
+                this.logger.info('Registering new package...');
+
+                const outSimulation: StrippedTransactionOutput[] = [
+                    {
+                        index: 1,
+                        to: treasuryAddress.properties.treasuryAddress,
+                        value: 10_000n,
+                        flags: TransactionOutputFlags.hasTo,
+                        scriptPubKey: undefined,
+                    },
+                ];
+
+                contract.setTransactionDetails({
+                    inputs: [],
+                    outputs: outSimulation,
+                });
+
+                const registerResult = await contract.registerPackage(meta.name);
+                if (registerResult.revert) {
+                    this.logger.fail('Package registration would fail');
+                    this.logger.error(`Reason: ${registerResult.revert}`);
+                    process.exit(1);
+                }
+
+                if (registerResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+                }
+
+                const registerReceipt = await registerResult.sendTransaction(txParams);
+                this.logger.success('Package registration transaction sent');
+                this.logger.log(`Transaction ID: ${registerReceipt.transactionId}`);
+                this.logger.log('');
+
+                // Wait for registration transaction to be confirmed
+                const confirmationResult = await waitForTransactionConfirmation(
+                    registerReceipt.transactionId,
+                    network,
+                    {
+                        message: 'Waiting for package registration to confirm',
+                    },
+                );
+
+                if (!confirmationResult.confirmed) {
+                    if (confirmationResult.revert) {
+                        this.logger.fail('Package registration failed');
+                        this.logger.error(`Reason: ${confirmationResult.revert}`);
+                    } else if (confirmationResult.error) {
+                        this.logger.fail('Package registration not confirmed');
+                        this.logger.error(confirmationResult.error);
+                    }
+                    process.exit(1);
+                }
+
+                this.logger.log('');
             }
 
+            txParams = buildTransactionParams(
+                wallet,
+                network,
+                DEFAULT_MAX_SAT_TO_SPEND,
+                DEFAULT_FEE_RATE,
+            );
+
             // Publish version
             this.logger.info('Publishing version...');
-            this.logger.warn('Version publishing required.');
-            this.logger.log('Transaction would call: publishVersion(');
-            this.logger.log(`  packageName: "${meta.name}",`);
-            this.logger.log(`  version: "${meta.version}",`);
-            this.logger.log(`  ipfsCid: "${pinResult.cid}",`);
-            this.logger.log(`  checksum: <32 bytes>,`);
-            this.logger.log(`  signature: <${parsed.signature.length} bytes>,`);
-            this.logger.log(`  mldsaLevel: ${mldsaLevelToRegistry(mldsaLevel)},`);
-            this.logger.log(`  opnetVersionRange: "${meta.opnetVersion}",`);
-            this.logger.log(`  pluginType: ${pluginTypeToRegistry(meta.pluginType)},`);
-            this.logger.log(`  permissionsHash: <32 bytes>,`);
-            this.logger.log(`  dependencies: <${dependencies.length} bytes>`);
-            this.logger.log(')');
-            this.logger.info('Version publishing (transaction pending)');
+
+            const publishResult = await contract.publishVersion(
+                meta.name,
+                meta.version,
+                pinResult.cid,
+                new Uint8Array(parsed.checksum),
+                new Uint8Array(parsed.signature),
+                mldsaLevelToRegistry(mldsaLevel),
+                meta.opnetVersion,
+                pluginTypeToRegistry(meta.pluginType),
+                permissionsHash,
+                dependencies,
+            );
+
+            if (publishResult.revert) {
+                this.logger.fail('Version publishing would fail');
+                this.logger.error(`Reason: ${publishResult.revert}`);
+                process.exit(1);
+            }
+
+            if (publishResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${publishResult.estimatedGas} sats`);
+            }
+
+            const publishReceipt = await publishResult.sendTransaction(txParams);
 
             this.logger.log('');
-            this.logger.success('Plugin uploaded successfully!');
-            this.logger.log('');
-            this.logger.log(`IPFS CID:  ${pinResult.cid}`);
-            this.logger.log(`Gateway:   https://ipfs.opnet.org/ipfs/${pinResult.cid}`);
+            this.logger.success('Plugin published successfully!');
             this.logger.log('');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
-            this.logger.warn(
-                'The binary has been uploaded to IPFS and is ready for registry submission.',
-            );
+            this.logger.log(`Package:        ${meta.name}`);
+            this.logger.log(`Version:        ${meta.version}`);
+            this.logger.log(`IPFS CID:       ${pinResult.cid}`);
+            this.logger.log(`Transaction ID: ${publishReceipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(publishReceipt.estimatedFees)}`);
+            this.logger.log(`Gateway:        https://ipfs.opnet.org/ipfs/${pinResult.cid}`);
             this.logger.log('');
         } catch (error) {
-            this.logger.fail('Publishing failed');
+            this.logger.fail(`Publishing failed`);
             if (this.isUserCancelled(error)) {
                 this.logger.warn('Publishing cancelled.');
                 process.exit(0);

package/src/commands/ScopeRegisterCommand.ts

@@ -0,0 +1,164 @@
+/**
+ * Scope Register command - Register a new scope in the registry
+ *
+ * @module commands/ScopeRegisterCommand
+ */
+
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getRegistryContract, getScope, getScopePrice } from '../lib/registry.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+import {
+    buildTransactionParams,
+    checkBalance,
+    formatSats,
+    getWalletAddress,
+} from '../lib/transaction.js';
+import { NetworkName } from '../types/index.js';
+
+interface ScopeRegisterOptions {
+    network: string;
+    yes?: boolean;
+}
+
+export class ScopeRegisterCommand extends BaseCommand {
+    constructor() {
+        super('scope:register', 'Register a new scope in the registry');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<name>', 'Scope name (without @)')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((name: string, options?: ScopeRegisterOptions) =>
+                this.execute(name, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(name: string, options?: ScopeRegisterOptions): Promise<void> {
+        try {
+            // Remove @ prefix if provided
+            const scopeName = name.startsWith('@') ? name.substring(1) : name;
+
+            // Validate scope name
+            if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(scopeName) && !/^[a-z]$/.test(scopeName)) {
+                this.logger.fail('Invalid scope name');
+                this.logger.error('Scope name must:');
+                this.logger.error('  - Start with a lowercase letter');
+                this.logger.error('  - Contain only lowercase letters, numbers, and hyphens');
+                this.logger.error('  - End with a letter or number');
+                process.exit(1);
+            }
+
+            // Load credentials
+            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);
+            }
+            const wallet = CLIWallet.fromCredentials(credentials);
+            this.logger.success('Wallet loaded');
+
+            const network = (options?.network || 'mainnet') as NetworkName;
+
+            // Check if scope already exists
+            this.logger.info(`Checking if @${scopeName} is available...`);
+            const existingScope = await getScope(scopeName, network);
+            if (existingScope) {
+                this.logger.fail('Scope already registered');
+                this.logger.error(`Scope @${scopeName} is already registered.`);
+                this.logger.log(`Owner: ${existingScope.owner}`);
+                process.exit(1);
+            }
+            this.logger.success(`Scope @${scopeName} is available`);
+
+            // Get scope registration price
+            this.logger.info('Fetching registration price...');
+            const scopePrice = await getScopePrice(network);
+            this.logger.success(`Registration price: ${formatSats(scopePrice)}`);
+
+            // Check wallet balance
+            this.logger.info('Checking wallet balance...');
+            const minRequired = scopePrice + 50_000n; // Price + estimated fees
+            const { sufficient, balance } = await checkBalance(wallet, network, minRequired);
+            if (!sufficient) {
+                this.logger.fail('Insufficient balance');
+                this.logger.error(`Wallet balance: ${formatSats(balance)}`);
+                this.logger.error(`Required (approx): ${formatSats(minRequired)}`);
+                this.logger.error('Please fund your wallet before registering a scope.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
+            // Display summary
+            this.logger.log('');
+            this.logger.info('Scope Registration Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Scope:    @${scopeName}`);
+            this.logger.log(`Price:    ${formatSats(scopePrice)}`);
+            this.logger.log(`Network:  ${options?.network}`);
+            this.logger.log(`Address:  ${wallet.p2trAddress}`);
+            this.logger.log('');
+
+            // Confirmation
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Register scope @${scopeName}?`,
+                    default: true,
+                });
+
+                if (!confirmed) {
+                    this.logger.warn('Registration cancelled.');
+                    return;
+                }
+            }
+
+            // Execute registration
+            this.logger.info('Registering scope...');
+
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const registerResult = await contract.registerScope(scopeName);
+
+            if (registerResult.revert) {
+                this.logger.fail('Registration would fail');
+                this.logger.error(`Reason: ${registerResult.revert}`);
+                process.exit(1);
+            }
+
+            if (registerResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+            }
+
+            const receipt = await registerResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Scope registered successfully!');
+            this.logger.log('');
+            this.logger.log(`Scope:          @${scopeName}`);
+            this.logger.log(`Owner:          ${wallet.p2trAddress}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            this.logger.log('');
+            this.logger.info(
+                'You can now publish packages under this scope using: opnet publish',
+            );
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Scope registration failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Registration cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+
+export const scopeRegisterCommand = new ScopeRegisterCommand().getCommand();

package/src/commands/SignCommand.ts

@@ -7,12 +7,7 @@
 import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { BaseCommand } from './BaseCommand.js';
-import {
-    buildOpnetBinary,
-    computeChecksum,
-    formatFileSize,
-    parseOpnetBinary,
-} from '../lib/binary.js';
+import { buildOpnetBinary, formatFileSize, parseOpnetBinary } from '../lib/binary.js';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 
@@ -77,27 +72,20 @@ export class SignCommand extends BaseCommand {
                 process.exit(1);
             }
 
-            // Compute new signature
-            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)`);
-
-            // Rebuild binary
-            this.logger.info('Rebuilding binary...');
-            const newBinary = buildOpnetBinary({
+            // Rebuild binary with signing
+            this.logger.info('Signing and rebuilding binary...');
+            const signFn = (checksum: Buffer) => wallet.signMLDSA(checksum);
+            const { binary: newBinary, checksum } = buildOpnetBinary({
                 mldsaLevel: wallet.securityLevel,
                 publicKey: wallet.mldsaPublicKey,
-                signature,
                 metadata: parsed.metadata,
                 bytecode: parsed.bytecode,
                 proto: parsed.proto ?? Buffer.alloc(0),
+                signFn,
             });
+            this.logger.success(
+                `Signed (checksum: sha256:${checksum.toString('hex').substring(0, 16)}...)`,
+            );
             this.logger.success(`Binary rebuilt (${formatFileSize(newBinary.length)})`);
 
             // Write output