@btc-vision/cli 1.0.2 → 1.0.3

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/TransferCommand.ts

@@ -5,15 +5,23 @@
  */
 
 import { confirm, input } from '@inquirer/prompts';
+import { Address } from '@btc-vision/transaction';
 import { BaseCommand } from './BaseCommand.js';
 import {
     getPackage,
     getPendingScopeTransfer,
     getPendingTransfer,
+    getRegistryContract,
     getScope,
 } 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 TransferOptions {
@@ -53,7 +61,7 @@ export class TransferCommand 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');
 
             const network = (options?.network || 'mainnet') as NetworkName;
@@ -129,28 +137,82 @@ export class TransferCommand 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 initiating transfer.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             // Execute transfer
             this.logger.info('Initiating transfer...');
 
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const newOwnerAddress = Address.fromString(targetOwner);
+
             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(')');
+                const transferResult = await contract.initiateScopeTransfer(
+                    scopeName,
+                    newOwnerAddress,
+                );
+
+                if (transferResult.revert) {
+                    this.logger.fail('Transfer initiation would fail');
+                    this.logger.error(`Reason: ${transferResult.revert}`);
+                    process.exit(1);
+                }
+
+                if (transferResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                }
+
+                const receipt = await transferResult.sendTransaction(txParams);
+
+                this.logger.log('');
+                this.logger.success('Scope transfer initiated successfully!');
+                this.logger.log('');
+                this.logger.log(`Scope:          ${name}`);
+                this.logger.log(`New Owner:      ${targetOwner}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+                this.logger.warn(
+                    'Note: The new owner must call `opnet accept` to complete the transfer.',
+                );
             } 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)');
+                const transferResult = await contract.initiateTransfer(name, newOwnerAddress);
 
-            this.logger.log('');
-            this.logger.success('Transfer initiated!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
+                if (transferResult.revert) {
+                    this.logger.fail('Transfer initiation would fail');
+                    this.logger.error(`Reason: ${transferResult.revert}`);
+                    process.exit(1);
+                }
+
+                if (transferResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                }
+
+                const receipt = await transferResult.sendTransaction(txParams);
+
+                this.logger.log('');
+                this.logger.success('Package transfer initiated successfully!');
+                this.logger.log('');
+                this.logger.log(`Package:        ${name}`);
+                this.logger.log(`New Owner:      ${targetOwner}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+                this.logger.warn(
+                    'Note: The new owner must call `opnet accept` to complete the transfer.',
+                );
+            }
             this.logger.log('');
         } catch (error) {
             this.logger.fail('Transfer failed');
@@ -170,6 +232,15 @@ export class TransferCommand extends BaseCommand {
     ): Promise<void> {
         this.logger.info('Checking pending transfer...');
 
+        // Load wallet for cancellation
+        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);
+
         if (isScope) {
             const scopeName = name.substring(1);
             const pending = await getPendingScopeTransfer(scopeName, network);
@@ -191,12 +262,43 @@ export class TransferCommand 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)}`);
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             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)');
+
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const cancelResult = await contract.cancelScopeTransfer(scopeName);
+
+            if (cancelResult.revert) {
+                this.logger.fail('Cancellation would fail');
+                this.logger.error(`Reason: ${cancelResult.revert}`);
+                process.exit(1);
+            }
+
+            if (cancelResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+            }
+
+            const receipt = await cancelResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Scope transfer cancelled successfully!');
+            this.logger.log('');
+            this.logger.log(`Scope:          ${name}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            this.logger.log('');
         } else {
             const pending = await getPendingTransfer(name, network);
             if (!pending) {
@@ -217,18 +319,44 @@ export class TransferCommand 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)}`);
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             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('');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const cancelResult = await contract.cancelTransfer(name);
+
+            if (cancelResult.revert) {
+                this.logger.fail('Cancellation would fail');
+                this.logger.error(`Reason: ${cancelResult.revert}`);
+                process.exit(1);
+            }
+
+            if (cancelResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+            }
+
+            const receipt = await cancelResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Package transfer cancelled successfully!');
+            this.logger.log('');
+            this.logger.log(`Package:        ${name}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            this.logger.log('');
+        }
     }
 }