@btc-vision/cli 1.0.7 → 1.0.9

package/build/commands/DomainCommand.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const domainCommand: Command;
+export { domainCommand };

package/build/commands/DomainCommand.js

@@ -0,0 +1,241 @@
+import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
+import { Logger } from '@btc-vision/logger';
+import { CLIWallet } from '../lib/wallet.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { getResolverContract, getDomain, getContenthash, getContenthashTypeName, validateDomainName, getTreasuryAddress, getDomainPrice, parseDomainName, } from '../lib/resolver.js';
+import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
+import { TransactionOutputFlags } from 'opnet';
+const logger = new Logger();
+async function registerDomain(domain, options) {
+    try {
+        const network = (options.network || 'mainnet');
+        const name = parseDomainName(domain.toLowerCase());
+        const displayName = `${name}.btc`;
+        if (name.includes('.')) {
+            logger.fail('Cannot register subdomains directly');
+            logger.info('Register the parent domain first, then create subdomains');
+            process.exit(1);
+        }
+        const validationError = validateDomainName(name);
+        if (validationError) {
+            logger.fail(`Invalid domain name: ${validationError}`);
+            process.exit(1);
+        }
+        logger.info(`Registering domain: ${displayName}`);
+        logger.info('Checking domain availability...');
+        const existingDomain = await getDomain(name, network);
+        if (existingDomain) {
+            logger.fail(`Domain ${displayName} is already registered`);
+            logger.log(`Owner: ${existingDomain.owner.toHex()}`);
+            process.exit(1);
+        }
+        logger.success(`Domain ${displayName} is available`);
+        const price = await getDomainPrice(name, network);
+        const treasuryAddr = await getTreasuryAddress(network);
+        logger.info(`Registration price: ${formatSats(price)}`);
+        if (name.length === 3) {
+            logger.warn('Premium pricing applied (3-character domain)');
+        }
+        else if (name.length === 4) {
+            logger.warn('Premium pricing applied (4-character domain)');
+        }
+        logger.info('Loading wallet...');
+        const credentials = loadCredentials();
+        if (!credentials || !canSign(credentials)) {
+            logger.fail('No credentials configured');
+            logger.warn('Run `opnet login` to configure your wallet.');
+            process.exit(1);
+        }
+        const wallet = CLIWallet.fromCredentials(credentials);
+        logger.success('Wallet loaded');
+        logger.info('Checking wallet balance...');
+        const minRequired = price + 10000n;
+        const { sufficient, balance } = await checkBalance(wallet, network, minRequired);
+        if (!sufficient) {
+            logger.fail('Insufficient balance');
+            logger.error(`Required: ~${formatSats(minRequired)}`);
+            logger.error(`Available: ${formatSats(balance)}`);
+            process.exit(1);
+        }
+        logger.success(`Wallet balance: ${formatSats(balance)}`);
+        logger.log('');
+        logger.info('Registration Summary');
+        logger.log('-'.repeat(50));
+        logger.log(`Domain:       ${displayName}`);
+        logger.log(`Price:        ${formatSats(price)}`);
+        logger.log(`Treasury:     ${treasuryAddr}`);
+        logger.log(`Network:      ${network}`);
+        logger.log(`Your wallet:  ${wallet.p2trAddress}`);
+        logger.log('');
+        if (options.dryRun) {
+            logger.warn('Dry run - no changes made.');
+            return;
+        }
+        if (!options.yes) {
+            const confirmed = await confirm({
+                message: `Register ${displayName} for ${formatSats(price)}?`,
+                default: true,
+            });
+            if (!confirmed) {
+                logger.warn('Registration cancelled.');
+                return;
+            }
+        }
+        logger.info('Preparing transaction...');
+        const sender = getWalletAddress(wallet);
+        const contract = getResolverContract(network, sender);
+        const extraUtxo = {
+            address: treasuryAddr,
+            value: Number(price),
+        };
+        const outSimulation = [
+            {
+                index: 1,
+                to: treasuryAddr,
+                value: price,
+                flags: TransactionOutputFlags.hasTo,
+                scriptPubKey: undefined,
+            },
+        ];
+        contract.setTransactionDetails({
+            inputs: [],
+            outputs: outSimulation,
+        });
+        const registerResult = await contract.registerDomain(name);
+        if (registerResult.revert) {
+            logger.fail('Registration would fail');
+            logger.error(`Reason: ${registerResult.revert}`);
+            process.exit(1);
+        }
+        if (registerResult.estimatedGas) {
+            logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+        }
+        const txParams = buildTransactionParams(wallet, network, DEFAULT_MAX_SAT_TO_SPEND + price, DEFAULT_FEE_RATE, extraUtxo);
+        const receipt = await registerResult.sendTransaction(txParams);
+        logger.log('');
+        logger.success('Domain registration submitted!');
+        logger.log('');
+        logger.log(`Domain:         ${displayName}`);
+        logger.log(`Transaction ID: ${receipt.transactionId}`);
+        logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+        logger.log('');
+        const confirmationResult = await waitForTransactionConfirmation(receipt.transactionId, network, {
+            message: 'Waiting for registration confirmation',
+        });
+        if (!confirmationResult.confirmed) {
+            if (confirmationResult.revert) {
+                logger.fail('Registration failed');
+                logger.error(`Reason: ${confirmationResult.revert}`);
+            }
+            else if (confirmationResult.error) {
+                logger.warn('Registration not yet confirmed');
+                logger.warn(confirmationResult.error);
+            }
+        }
+        else {
+            logger.log('');
+            logger.success(`You now own ${displayName}!`);
+            logger.info('Next step: publish your website with:');
+            logger.log(`  opnet website ${name} <ipfs-cid> -n ${network}`);
+        }
+    }
+    catch (error) {
+        logger.fail('Domain registration failed');
+        if (error instanceof Error && error.message.includes('User force closed')) {
+            logger.warn('Registration cancelled.');
+            process.exit(0);
+        }
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function domainInfo(domain, options) {
+    try {
+        const network = (options.network || 'mainnet');
+        const name = parseDomainName(domain.toLowerCase());
+        const displayName = `${name}.btc`;
+        logger.info(`Looking up: ${displayName}`);
+        const domainData = await getDomain(name, network);
+        if (!domainData) {
+            logger.warn(`Domain ${displayName} is not registered`);
+            const price = await getDomainPrice(name, network);
+            logger.log('');
+            logger.info('Registration Info');
+            logger.log('-'.repeat(50));
+            logger.log(`Domain:       ${displayName}`);
+            logger.log(`Status:       Available`);
+            logger.log(`Price:        ${formatSats(price)}`);
+            if (name.length === 3) {
+                logger.log(`Pricing tier: Premium (3-character)`);
+            }
+            else if (name.length === 4) {
+                logger.log(`Pricing tier: Premium (4-character)`);
+            }
+            else {
+                logger.log(`Pricing tier: Standard`);
+            }
+            logger.log('');
+            logger.info('Register with:');
+            logger.log(`  opnet domain register ${name} -n ${network}`);
+            return;
+        }
+        const contenthash = await getContenthash(name, network);
+        logger.log('');
+        logger.info('Domain Information');
+        logger.log('-'.repeat(50));
+        logger.log(`Domain:       ${displayName}`);
+        logger.log(`Status:       Registered`);
+        logger.log(`Owner:        ${domainData.owner.toHex()}`);
+        logger.log(`Created at:   Block #${domainData.createdAt}`);
+        logger.log(`TTL:          ${domainData.ttl} seconds`);
+        if (contenthash.hashType !== 0) {
+            logger.log('');
+            logger.info('Website (Contenthash)');
+            logger.log('-'.repeat(50));
+            logger.log(`Type:         ${getContenthashTypeName(contenthash.hashType)}`);
+            if (contenthash.hashString) {
+                logger.log(`Value:        ${contenthash.hashString}`);
+                if (contenthash.hashType === 1 || contenthash.hashType === 2) {
+                    logger.log(`Gateway URL:  https://ipfs.opnet.org/ipfs/${contenthash.hashString}`);
+                }
+                else if (contenthash.hashType === 3) {
+                    logger.log(`Gateway URL:  https://ipfs.opnet.org/ipns/${contenthash.hashString}`);
+                }
+            }
+            else {
+                const hashHex = Buffer.from(contenthash.hashData).toString('hex');
+                logger.log(`Value:        ${hashHex}`);
+            }
+        }
+        else {
+            logger.log('');
+            logger.warn('No website published');
+            logger.info('Publish with:');
+            logger.log(`  opnet website ${name} <ipfs-cid> -n ${network}`);
+        }
+        logger.log('');
+    }
+    catch (error) {
+        logger.fail('Failed to get domain info');
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+const domainCommand = new Command('domain')
+    .description('Manage .btc domains');
+domainCommand
+    .command('register')
+    .description('Register a new .btc domain')
+    .argument('<name>', 'Domain name to register (without .btc suffix)')
+    .option('-n, --network <network>', 'Network to use', 'mainnet')
+    .option('--dry-run', 'Show what would happen without registering')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action((name, options) => registerDomain(name, options));
+domainCommand
+    .command('info')
+    .description('Get information about a .btc domain')
+    .argument('<name>', 'Domain name to look up (with or without .btc suffix)')
+    .option('-n, --network <network>', 'Network to use', 'mainnet')
+    .action((name, options) => domainInfo(name, options));
+export { domainCommand };

package/build/commands/InstallCommand.d.ts

@@ -3,5 +3,7 @@ export declare class InstallCommand extends BaseCommand {
     constructor();
     protected configure(): void;
     private execute;
+    private removeOldVersions;
+    private escapeRegex;
 }
 export declare const installCommand: import("commander").Command;

package/build/commands/InstallCommand.js

@@ -106,8 +106,10 @@ export class InstallCommand extends BaseCommand {
             }
             const outputDir = options?.output || path.join(process.cwd(), 'plugins');
             fs.mkdirSync(outputDir, { recursive: true });
-            const fileName = `${packageName.replace(/^@/, '').replace(/\//g, '-')}-${version}.opnet`;
+            const packageBaseName = packageName.replace(/^@/, '').replace(/\//g, '-');
+            const fileName = `${packageBaseName}-${version}.opnet`;
             const outputPath = path.join(outputDir, fileName);
+            this.removeOldVersions(outputDir, packageBaseName, version);
             this.logger.info('Saving plugin...');
             fs.writeFileSync(outputPath, result.data);
             this.logger.success('Plugin installed');
@@ -126,5 +128,31 @@ export class InstallCommand extends BaseCommand {
             this.exitWithError(this.formatError(error));
         }
     }
+    removeOldVersions(outputDir, packageBaseName, newVersion) {
+        try {
+            const entries = fs.readdirSync(outputDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith('.opnet')) {
+                    continue;
+                }
+                const pattern = new RegExp(`^${this.escapeRegex(packageBaseName)}-(.+)\\.opnet$`);
+                const match = entry.name.match(pattern);
+                if (match) {
+                    const oldVersion = match[1];
+                    if (oldVersion !== newVersion) {
+                        const oldFilePath = path.join(outputDir, entry.name);
+                        this.logger.info(`Removing old version: ${entry.name}`);
+                        fs.unlinkSync(oldFilePath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Could not clean up old versions: ${this.formatError(error)}`);
+        }
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
 }
 export const installCommand = new InstallCommand().getCommand();

package/build/commands/LoginCommand.js

@@ -76,9 +76,9 @@ export class LoginCommand extends BaseCommand {
                 network: options.network,
             };
         }
-        return this.interactiveLogin(options.network, mldsaLevel);
+        return this.interactiveLogin(options.network);
     }
-    async interactiveLogin(defaultNetwork, defaultLevel) {
+    async interactiveLogin(defaultNetwork) {
         this.logger.info('OPNet Wallet Configuration\n');
         const loginMethod = await select({
             message: 'How would you like to authenticate?',
@@ -104,27 +104,8 @@ export class LoginCommand extends BaseCommand {
             ],
             default: defaultNetwork,
         }));
-        const selectedLevel = (await select({
-            message: 'Select MLDSA security level:',
-            choices: [
-                {
-                    name: 'MLDSA-44 (Level 2, fastest)',
-                    value: 44,
-                    description: '1312 byte public key',
-                },
-                {
-                    name: 'MLDSA-65 (Level 3, balanced)',
-                    value: 65,
-                    description: '1952 byte public key',
-                },
-                {
-                    name: 'MLDSA-87 (Level 5, most secure)',
-                    value: 87,
-                    description: '2592 byte public key',
-                },
-            ],
-            default: defaultLevel,
-        }));
+        const selectedLevel = 44;
+        this.logger.info('Using MLDSA-44 (only supported level on OPNet)');
         if (loginMethod === 'mnemonic') {
             const mnemonic = await password({
                 message: 'Enter your mnemonic phrase (12 or 24 words):',

package/build/commands/WebsiteDeployCommand.d.ts

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

package/build/commands/WebsiteDeployCommand.js

@@ -0,0 +1,214 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { uploadDirectory, uploadFile } from '../lib/ipfs.js';
+import { formatFileSize } from '../lib/binary.js';
+import { getResolverContract, getDomain, getSubdomain, getContenthash, getContenthashTypeName, isSubdomain, parseDomainName, } from '../lib/resolver.js';
+import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
+export class WebsiteDeployCommand extends BaseCommand {
+    constructor() {
+        super('deploy', 'Upload website to IPFS and publish to .btc domain');
+    }
+    configure() {
+        this.command
+            .argument('<domain>', 'Domain name (e.g., mysite or mysite.btc)')
+            .argument('<path>', 'Path to website directory or HTML file')
+            .option('-n, --network <network>', 'Network to use', 'mainnet')
+            .option('--dry-run', 'Upload to IPFS but don\'t update on-chain')
+            .option('-y, --yes', 'Skip confirmation prompts')
+            .action((domain, websitePath, options) => this.execute(domain, websitePath, options || { network: 'mainnet' }));
+    }
+    async execute(domain, websitePath, options) {
+        try {
+            const network = (options.network || 'mainnet');
+            const name = parseDomainName(domain.toLowerCase());
+            const isSubdomainName = isSubdomain(name);
+            const displayName = `${name}.btc`;
+            const resolvedPath = path.resolve(websitePath);
+            if (!fs.existsSync(resolvedPath)) {
+                this.logger.fail(`Path not found: ${resolvedPath}`);
+                process.exit(1);
+            }
+            const stats = fs.statSync(resolvedPath);
+            const isDirectory = stats.isDirectory();
+            this.logger.info(`Deploying to ${displayName}...`);
+            this.logger.log('');
+            if (isDirectory) {
+                const files = this.countFiles(resolvedPath);
+                const totalSize = this.getDirectorySize(resolvedPath);
+                this.logger.info('Website Directory');
+                this.logger.log('-'.repeat(50));
+                this.logger.log(`Path:         ${resolvedPath}`);
+                this.logger.log(`Files:        ${files}`);
+                this.logger.log(`Total size:   ${formatFileSize(totalSize)}`);
+            }
+            else {
+                this.logger.info('Website File');
+                this.logger.log('-'.repeat(50));
+                this.logger.log(`Path:         ${resolvedPath}`);
+                this.logger.log(`Size:         ${formatFileSize(stats.size)}`);
+            }
+            this.logger.log('');
+            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');
+            this.logger.info('Checking domain ownership...');
+            let ownerAddress;
+            if (isSubdomainName) {
+                const subdomainInfo = await getSubdomain(name, network);
+                if (!subdomainInfo) {
+                    this.logger.fail(`Subdomain ${displayName} does not exist`);
+                    process.exit(1);
+                }
+                ownerAddress = subdomainInfo.owner.toHex();
+            }
+            else {
+                const domainInfo = await getDomain(name, network);
+                if (!domainInfo) {
+                    this.logger.fail(`Domain ${displayName} does not exist`);
+                    this.logger.info('Register the domain first with:');
+                    this.logger.log(`  opnet domain register ${name} -n ${network}`);
+                    process.exit(1);
+                }
+                ownerAddress = domainInfo.owner.toHex();
+            }
+            if (wallet.address.toHex() !== ownerAddress) {
+                this.logger.fail('You are not the owner of this domain');
+                this.logger.log(`Domain owner: ${ownerAddress}`);
+                this.logger.log(`Your address: ${wallet.address.toHex()}`);
+                process.exit(1);
+            }
+            this.logger.success('Ownership verified');
+            const currentContenthash = await getContenthash(name, network);
+            if (currentContenthash.hashType !== 0) {
+                this.logger.warn(`Current website: ${currentContenthash.hashString || 'SHA256 hash'} (${getContenthashTypeName(currentContenthash.hashType)})`);
+            }
+            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 to pay for gas fees.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+            if (!options.yes) {
+                const confirmed = await confirm({
+                    message: `Upload and deploy to ${displayName}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Deployment cancelled.');
+                    return;
+                }
+            }
+            this.logger.log('');
+            this.logger.info('Uploading to IPFS...');
+            let cid;
+            if (isDirectory) {
+                const result = await uploadDirectory(resolvedPath);
+                cid = result.cid;
+                this.logger.success(`Uploaded ${result.files} files (${formatFileSize(result.totalSize)})`);
+            }
+            else {
+                const result = await uploadFile(resolvedPath);
+                cid = result.cid;
+                this.logger.success(`Uploaded file (${formatFileSize(result.size)})`);
+            }
+            this.logger.success(`IPFS CID: ${cid}`);
+            this.logger.log(`Gateway URL: https://ipfs.opnet.org/ipfs/${cid}`);
+            this.logger.log('');
+            if (options.dryRun) {
+                this.logger.warn('Dry run - website uploaded to IPFS but not published on-chain.');
+                this.logger.info('To publish on-chain, run:');
+                this.logger.log(`  opnet website ${name} ${cid} -n ${network}`);
+                return;
+            }
+            this.logger.info('Publishing to blockchain...');
+            const sender = getWalletAddress(wallet);
+            const contract = getResolverContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network, DEFAULT_MAX_SAT_TO_SPEND, DEFAULT_FEE_RATE);
+            const result = await contract.setContenthashCIDv1(name, cid);
+            if (result.revert) {
+                this.logger.fail('Transaction would fail');
+                this.logger.error(`Reason: ${result.revert}`);
+                process.exit(1);
+            }
+            if (result.estimatedGas) {
+                this.logger.info(`Estimated gas: ${result.estimatedGas} sats`);
+            }
+            const receipt = await result.sendTransaction(txParams);
+            this.logger.log('');
+            this.logger.success('Website deployed successfully!');
+            this.logger.log('');
+            this.logger.log(`Domain:         ${displayName}`);
+            this.logger.log(`IPFS CID:       ${cid}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            this.logger.log(`Gateway URL:    https://ipfs.opnet.org/ipfs/${cid}`);
+            this.logger.log('');
+            const confirmationResult = await waitForTransactionConfirmation(receipt.transactionId, network, {
+                message: 'Waiting for transaction confirmation',
+            });
+            if (!confirmationResult.confirmed) {
+                if (confirmationResult.revert) {
+                    this.logger.fail('Transaction failed');
+                    this.logger.error(`Reason: ${confirmationResult.revert}`);
+                }
+                else if (confirmationResult.error) {
+                    this.logger.warn('Transaction not yet confirmed');
+                    this.logger.warn(confirmationResult.error);
+                }
+            }
+            else {
+                this.logger.log('');
+                this.logger.success(`${displayName} is now live!`);
+            }
+        }
+        catch (error) {
+            this.logger.fail('Deployment failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Deployment cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+    countFiles(dirPath) {
+        let count = 0;
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                count += this.countFiles(path.join(dirPath, entry.name));
+            }
+            else if (entry.isFile()) {
+                count++;
+            }
+        }
+        return count;
+    }
+    getDirectorySize(dirPath) {
+        let size = 0;
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                size += this.getDirectorySize(fullPath);
+            }
+            else if (entry.isFile()) {
+                size += fs.statSync(fullPath).size;
+            }
+        }
+        return size;
+    }
+}
+export const websiteDeployCommand = new WebsiteDeployCommand().getCommand();

package/build/commands/WebsitePublishCommand.d.ts

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