@btc-vision/cli 1.0.1 → 1.0.3

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('');
+        }
     }
 }
 

package/src/commands/UndeprecateCommand.ts

@@ -6,9 +6,15 @@
 
 import { confirm } 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 UndeprecateOptions {
@@ -46,7 +52,7 @@ export class UndeprecateCommand 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
@@ -107,18 +113,45 @@ export class UndeprecateCommand 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 undeprecating.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             // Execute undeprecation
             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)');
 
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const undeprecateResult = await contract.undeprecateVersion(packageName, version);
+
+            if (undeprecateResult.revert) {
+                this.logger.fail('Undeprecation would fail');
+                this.logger.error(`Reason: ${undeprecateResult.revert}`);
+                process.exit(1);
+            }
+
+            if (undeprecateResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${undeprecateResult.estimatedGas} sats`);
+            }
+
+            const receipt = await undeprecateResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Deprecation removed successfully!');
             this.logger.log('');
-            this.logger.success('Undeprecation submitted!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log(`Package:        ${packageName}`);
+            this.logger.log(`Version:        ${version}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
             this.logger.log('');
         } catch (error) {
             this.logger.fail('Undeprecation failed');

package/src/index.ts

@@ -24,6 +24,7 @@ import { deprecateCommand } from './commands/DeprecateCommand.js';
 import { undeprecateCommand } from './commands/UndeprecateCommand.js';
 import { transferCommand } from './commands/TransferCommand.js';
 import { acceptCommand } from './commands/AcceptCommand.js';
+import { scopeRegisterCommand } from './commands/ScopeRegisterCommand.js';
 import { installCommand } from './commands/InstallCommand.js';
 import { updateCommand } from './commands/UpdateCommand.js';
 import { listCommand } from './commands/ListCommand.js';
@@ -57,6 +58,7 @@ program.addCommand(deprecateCommand);
 program.addCommand(undeprecateCommand);
 program.addCommand(transferCommand);
 program.addCommand(acceptCommand);
+program.addCommand(scopeRegisterCommand);
 program.addCommand(installCommand);
 program.addCommand(updateCommand);
 program.addCommand(listCommand);

package/src/lib/binary.ts

@@ -184,28 +184,21 @@ export function verifyChecksum(parsed: IParsedPluginFile): boolean {
  * Build a .opnet binary file
  *
  * @param options - Build options
- * @returns The assembled binary
+ * @returns The assembled binary and the checksum that was signed
  */
 export function buildOpnetBinary(options: {
     mldsaLevel: CLIMldsaLevel;
     publicKey: Buffer;
-    signature: Buffer;
     metadata: IPluginMetadata;
     bytecode: Buffer;
     proto?: Buffer;
-}): Buffer {
-    const {
-        mldsaLevel,
-        publicKey,
-        signature,
-        metadata,
-        bytecode,
-        proto = Buffer.alloc(0),
-    } = options;
+    signFn?: (checksum: Buffer) => Buffer;
+}): { binary: Buffer; checksum: Buffer } {
+    const { mldsaLevel, publicKey, metadata, bytecode, proto = Buffer.alloc(0), signFn } = options;
 
     const sdkLevel = cliLevelToMLDSALevel(mldsaLevel);
 
-    // Validate sizes
+    // Validate public key size
     const expectedPkSize = MLDSA_PUBLIC_KEY_SIZES[sdkLevel];
     const expectedSigSize = MLDSA_SIGNATURE_SIZES[sdkLevel];
 
@@ -215,19 +208,28 @@ export function buildOpnetBinary(options: {
         );
     }
 
+    // First pass: compute checksum without the checksum field set
+    const tempMetadata = { ...metadata, checksum: '' };
+    const tempMetadataBytes = Buffer.from(JSON.stringify(tempMetadata), 'utf-8');
+    const checksum = computeChecksum(tempMetadataBytes, bytecode, proto);
+    const checksumHex = `sha256:${checksum.toString('hex')}`;
+
+    // Second pass: serialize metadata with checksum included
+    const finalMetadata = { ...metadata, checksum: checksumHex };
+    const metadataBytes = Buffer.from(JSON.stringify(finalMetadata), 'utf-8');
+
+    // Recompute checksum with the final metadata (includes checksum field)
+    const finalChecksum = computeChecksum(metadataBytes, bytecode, proto);
+
+    // Sign the final checksum (this is what gets verified)
+    const signature = signFn ? signFn(finalChecksum) : Buffer.alloc(expectedSigSize);
+
     if (signature.length !== expectedSigSize) {
         throw new Error(
             `Signature size mismatch: expected ${expectedSigSize}, got ${signature.length}`,
         );
     }
 
-    // Serialize metadata
-    const metadataStr = JSON.stringify(metadata);
-    const metadataBytes = Buffer.from(metadataStr, 'utf-8');
-
-    // Compute checksum
-    const checksum = computeChecksum(metadataBytes, bytecode, proto);
-
     // Calculate total size
     const totalSize =
         8 + // magic
@@ -291,10 +293,10 @@ export function buildOpnetBinary(options: {
     proto.copy(buffer, offset);
     offset += proto.length;
 
-    // Checksum
-    checksum.copy(buffer, offset);
+    // Checksum (use finalChecksum which was computed with metadata containing checksum hex)
+    finalChecksum.copy(buffer, offset);
 
-    return buffer;
+    return { binary: buffer, checksum: finalChecksum };
 }
 
 /**

package/src/lib/config.ts

@@ -19,7 +19,7 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 /**
  * Default CLI configuration
  */
-const DEFAULT_CONFIG: CLIConfig = {
+export const DEFAULT_CONFIG: CLIConfig = {
     defaultNetwork: 'regtest',
     rpcUrls: {
         mainnet: 'https://api.opnet.org',
@@ -35,11 +35,12 @@ const DEFAULT_CONFIG: CLIConfig = {
     ],
     ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
     ipfsPinningApiKey: '',
+    ipfsPinningSecret: '',
     ipfsPinningAuthHeader: 'Authorization',
     registryAddresses: {
         mainnet: '', // TODO: Set once deployed
         testnet: '', // TODO: Set once deployed
-        regtest: '', // TODO: Set once deployed
+        regtest: '0x0737d17d0eff9915208f3c20ed7659587889bc94d25972672b3a6c03ff4ddbcc', // TODO: Set once deployed
     },
     defaultMldsaLevel: 44,
     indexerUrl: 'https://indexer.opnet.org',