@btc-vision/cli 1.0.7 → 1.0.8

package/build/commands/WebsitePublishCommand.js

@@ -0,0 +1,234 @@
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { detectContenthashType, getContenthash, getContenthashTypeName, getDomain, getResolverContract, getSubdomain, isSubdomain, parseDomainName, validateCIDv0, validateCIDv1, validateIPNS, } from '../lib/resolver.js';
+import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
+import { CONTENTHASH_TYPE_CIDv0, CONTENTHASH_TYPE_CIDv1, CONTENTHASH_TYPE_IPNS, CONTENTHASH_TYPE_SHA256, } from '../types/BtcResolver.js';
+export class WebsitePublishCommand extends BaseCommand {
+    constructor() {
+        super('website', 'Publish a website to a .btc domain');
+    }
+    configure() {
+        this.command
+            .argument('<domain>', 'Domain name (e.g., mysite or mysite.btc)')
+            .argument('<contenthash>', 'IPFS CID, IPNS ID, or SHA256 hash')
+            .option('-n, --network <network>', 'Network to use', 'mainnet')
+            .option('--dry-run', 'Show what would be published without publishing')
+            .option('-y, --yes', 'Skip confirmation prompts')
+            .option('-t, --type <type>', 'Contenthash type: cidv0, cidv1, ipns, sha256 (auto-detected if not specified)')
+            .action((domain, contenthash, options) => this.execute(domain, contenthash, options || { network: 'mainnet' }));
+    }
+    async execute(domain, contenthash, options) {
+        try {
+            const network = (options.network || 'mainnet');
+            const name = parseDomainName(domain.toLowerCase());
+            const isSubdomainName = isSubdomain(name);
+            const displayName = `${name}.btc`;
+            this.logger.info(`Publishing website to ${displayName}...`);
+            let hashType;
+            if (options.type) {
+                switch (options.type.toLowerCase()) {
+                    case 'cidv0':
+                        hashType = CONTENTHASH_TYPE_CIDv0;
+                        break;
+                    case 'cidv1':
+                        hashType = CONTENTHASH_TYPE_CIDv1;
+                        break;
+                    case 'ipns':
+                        hashType = CONTENTHASH_TYPE_IPNS;
+                        break;
+                    case 'sha256':
+                        hashType = CONTENTHASH_TYPE_SHA256;
+                        break;
+                    default:
+                        this.logger.fail(`Invalid type: ${options.type}`);
+                        this.logger.info('Valid types: cidv0, cidv1, ipns, sha256');
+                        process.exit(1);
+                }
+            }
+            else {
+                const detected = detectContenthashType(contenthash);
+                if (detected === null) {
+                    this.logger.fail('Could not detect contenthash type');
+                    this.logger.info('Specify the type with --type option');
+                    this.logger.info('Valid types: cidv0, cidv1, ipns, sha256');
+                    process.exit(1);
+                }
+                hashType = detected;
+            }
+            let validationError = null;
+            switch (hashType) {
+                case CONTENTHASH_TYPE_CIDv0:
+                    validationError = validateCIDv0(contenthash);
+                    break;
+                case CONTENTHASH_TYPE_CIDv1:
+                    validationError = validateCIDv1(contenthash);
+                    break;
+                case CONTENTHASH_TYPE_IPNS:
+                    validationError = validateIPNS(contenthash);
+                    break;
+                case CONTENTHASH_TYPE_SHA256:
+                    if (!/^[0-9a-fA-F]{64}$/.test(contenthash)) {
+                        validationError = 'SHA256 hash must be 64 hex characters';
+                    }
+                    break;
+            }
+            if (validationError) {
+                this.logger.fail(`Invalid contenthash: ${validationError}`);
+                process.exit(1);
+            }
+            this.logger.success(`Contenthash type: ${getContenthashTypeName(hashType)}`);
+            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');
+                    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.p2trAddress}`);
+                this.logger.log(`MLDSA Public Key Hash:  ${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 contenthash: ${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)}`);
+            this.logger.log('');
+            this.logger.info('Publishing Summary');
+            this.logger.log('-'.repeat(50));
+            this.logger.log(`Domain:       ${displayName}`);
+            this.logger.log(`Type:         ${getContenthashTypeName(hashType)}`);
+            this.logger.log(`Contenthash:  ${contenthash}`);
+            this.logger.log(`Network:      ${network}`);
+            if (hashType === CONTENTHASH_TYPE_CIDv0 || hashType === CONTENTHASH_TYPE_CIDv1) {
+                this.logger.log(`Gateway URL:  https://ipfs.opnet.org/ipfs/${contenthash}`);
+            }
+            else if (hashType === CONTENTHASH_TYPE_IPNS) {
+                this.logger.log(`Gateway URL:  https://ipfs.opnet.org/ipns/${contenthash}`);
+            }
+            this.logger.log('');
+            if (options.dryRun) {
+                this.logger.warn('Dry run - no changes made.');
+                return;
+            }
+            if (!options.yes) {
+                const confirmed = await confirm({
+                    message: 'Publish website to this domain?',
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Publishing cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Setting contenthash...');
+            const sender = getWalletAddress(wallet);
+            const contract = getResolverContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network, DEFAULT_MAX_SAT_TO_SPEND, DEFAULT_FEE_RATE);
+            let result;
+            if (hashType === CONTENTHASH_TYPE_CIDv0) {
+                result = await contract.setContenthashCIDv0(name, contenthash);
+            }
+            else if (hashType === CONTENTHASH_TYPE_CIDv1) {
+                result = await contract.setContenthashCIDv1(name, contenthash);
+            }
+            else if (hashType === CONTENTHASH_TYPE_IPNS) {
+                result = await contract.setContenthashIPNS(name, contenthash);
+            }
+            else if (hashType === CONTENTHASH_TYPE_SHA256) {
+                const hexMatches = contenthash.match(/.{1,2}/g);
+                if (!hexMatches) {
+                    this.logger.fail('Invalid SHA256 hash format');
+                    process.exit(1);
+                }
+                const hashBytes = new Uint8Array(hexMatches.map((byte) => parseInt(byte, 16)));
+                result = await contract.setContenthashSHA256(name, hashBytes);
+            }
+            else {
+                this.logger.fail('Unknown contenthash type');
+                process.exit(1);
+            }
+            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 published successfully!');
+            this.logger.log('');
+            this.logger.log(`Domain:         ${displayName}`);
+            this.logger.log(`Contenthash:    ${contenthash}`);
+            this.logger.log(`Type:           ${getContenthashTypeName(hashType)}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            if (hashType === CONTENTHASH_TYPE_CIDv0 || hashType === CONTENTHASH_TYPE_CIDv1) {
+                this.logger.log(`Gateway URL:    https://ipfs.opnet.org/ipfs/${contenthash}`);
+            }
+            else if (hashType === CONTENTHASH_TYPE_IPNS) {
+                this.logger.log(`Gateway URL:    https://ipfs.opnet.org/ipns/${contenthash}`);
+            }
+            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);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.fail('Website publishing failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Publishing cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const websitePublishCommand = new WebsitePublishCommand().getCommand();

package/build/index.js

@@ -21,6 +21,9 @@ import { installCommand } from './commands/InstallCommand.js';
 import { updateCommand } from './commands/UpdateCommand.js';
 import { listCommand } from './commands/ListCommand.js';
 import { searchCommand } from './commands/SearchCommand.js';
+import { websitePublishCommand } from './commands/WebsitePublishCommand.js';
+import { domainCommand } from './commands/DomainCommand.js';
+import { websiteDeployCommand } from './commands/WebsiteDeployCommand.js';
 const logger = new Logger();
 const program = new Command();
 program
@@ -47,6 +50,9 @@ program.addCommand(installCommand);
 program.addCommand(updateCommand);
 program.addCommand(listCommand);
 program.addCommand(searchCommand);
+program.addCommand(domainCommand);
+program.addCommand(websitePublishCommand);
+program.addCommand(websiteDeployCommand);
 program.showHelpAfterError();
 program.showSuggestionAfterError();
 program.exitOverride((err) => {

package/build/lib/BtcResolver.abi.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinInterfaceAbi } from 'opnet';
+export declare const BTC_RESOLVER_ABI: BitcoinInterfaceAbi;

package/build/lib/BtcResolver.abi.js

@@ -0,0 +1,280 @@
+import { BitcoinAbiTypes } from 'opnet';
+import { ABIDataTypes } from '@btc-vision/transaction';
+export const BTC_RESOLVER_ABI = [
+    {
+        name: 'setTreasuryAddress',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'treasuryAddress', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'setDomainPrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+        outputs: [],
+    },
+    {
+        name: 'registerDomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'initiateTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'domainName', type: ABIDataTypes.STRING },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'acceptTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'cancelTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'createSubdomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'parentDomain', type: ABIDataTypes.STRING },
+            { name: 'subdomainLabel', type: ABIDataTypes.STRING },
+            { name: 'subdomainOwner', type: ABIDataTypes.ADDRESS },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'deleteSubdomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'parentDomain', type: ABIDataTypes.STRING },
+            { name: 'subdomainLabel', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'setContenthashCIDv0',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'name', type: ABIDataTypes.STRING },
+            { name: 'cid', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'setContenthashCIDv1',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'name', type: ABIDataTypes.STRING },
+            { name: 'cid', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'setContenthashIPNS',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'name', type: ABIDataTypes.STRING },
+            { name: 'ipnsId', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'setContenthashSHA256',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'name', type: ABIDataTypes.STRING },
+            { name: 'hash', type: ABIDataTypes.BYTES32 },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'clearContenthash',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'name', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'setTTL',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'name', type: ABIDataTypes.STRING },
+            { name: 'ttl', type: ABIDataTypes.UINT64 },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'getDomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'exists', type: ABIDataTypes.BOOL },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'createdAt', type: ABIDataTypes.UINT64 },
+            { name: 'ttl', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getSubdomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'fullName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'exists', type: ABIDataTypes.BOOL },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'parentHash', type: ABIDataTypes.BYTES32 },
+            { name: 'ttl', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getContenthash',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'name', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'hashType', type: ABIDataTypes.UINT8 },
+            { name: 'hashData', type: ABIDataTypes.BYTES32 },
+            { name: 'hashString', type: ABIDataTypes.STRING },
+        ],
+    },
+    {
+        name: 'resolve',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'name', type: ABIDataTypes.STRING }],
+        outputs: [{ name: 'owner', type: ABIDataTypes.ADDRESS }],
+    },
+    {
+        name: 'getPendingTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'pendingOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'initiatedAt', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getTreasuryAddress',
+        type: BitcoinAbiTypes.Function,
+        inputs: [],
+        outputs: [{ name: 'treasuryAddress', type: ABIDataTypes.STRING }],
+    },
+    {
+        name: 'getDomainPrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
+        outputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+    },
+    {
+        name: 'getBaseDomainPrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [],
+        outputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+    },
+    {
+        name: 'DomainRegistered',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'domainHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'DomainTransferInitiated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'domainHash', type: ABIDataTypes.UINT256 },
+            { name: 'currentOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'DomainTransferCompleted',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'domainHash', type: ABIDataTypes.UINT256 },
+            { name: 'previousOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'DomainTransferCancelled',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'domainHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'SubdomainCreated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'parentDomainHash', type: ABIDataTypes.UINT256 },
+            { name: 'subdomainHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'SubdomainDeleted',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'parentDomainHash', type: ABIDataTypes.UINT256 },
+            { name: 'subdomainHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ContenthashChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'nameHash', type: ABIDataTypes.UINT256 },
+            { name: 'contenthashType', type: ABIDataTypes.UINT8 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ContenthashCleared',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'nameHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'TTLChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'nameHash', type: ABIDataTypes.UINT256 },
+            { name: 'oldTTL', type: ABIDataTypes.UINT64 },
+            { name: 'newTTL', type: ABIDataTypes.UINT64 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'DomainPriceChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'oldPrice', type: ABIDataTypes.UINT64 },
+            { name: 'newPrice', type: ABIDataTypes.UINT64 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'TreasuryChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'previousAddressHash', type: ABIDataTypes.UINT256 },
+            { name: 'newAddressHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+];

package/build/lib/config.js

@@ -21,6 +21,11 @@ export const DEFAULT_CONFIG = {
         testnet: '',
         regtest: '0x0737d17d0eff9915208f3c20ed7659587889bc94d25972672b3a6c03ff4ddbcc',
     },
+    resolverAddresses: {
+        mainnet: '',
+        testnet: '',
+        regtest: '0x336dcb0b117e29a61aef4856dc438f9951de39edcc4745a255713da8f807779c',
+    },
     defaultMldsaLevel: 44,
     indexerUrl: 'https://indexer.opnet.org',
 };
@@ -92,6 +97,12 @@ export function loadConfig() {
             ...fileConfig.registryAddresses,
             ...envOverrides.registryAddresses,
         },
+        resolverAddresses: fileConfig.resolverAddresses
+            ? {
+                ...DEFAULT_CONFIG.resolverAddresses,
+                ...fileConfig.resolverAddresses,
+            }
+            : DEFAULT_CONFIG.resolverAddresses,
     };
 }
 export function saveConfig(config) {

package/build/lib/ipfs.d.ts

@@ -12,3 +12,10 @@ export declare function buildGatewayUrl(gateway: string, cid: string): string;
 export declare function isValidCid(cid: string): boolean;
 export declare function downloadPlugin(cid: string, outputPath: string): Promise<number>;
 export declare function uploadPlugin(filePath: string): Promise<PinResult>;
+export interface DirectoryPinResult {
+    cid: string;
+    files: number;
+    totalSize: number;
+}
+export declare function uploadDirectory(dirPath: string, wrapWithDirectory?: boolean): Promise<DirectoryPinResult>;
+export declare function uploadFile(filePath: string): Promise<PinResult>;