@btc-vision/cli 1.0.5 → 1.0.7

package/src/lib/registry.ts

@@ -1,467 +0,0 @@
-/**
- * Package Registry contract interactions for OPNet CLI
- *
- * Provides functions for interacting with the on-chain PackageRegistry contract.
- *
- * @module lib/registry
- */
-
-import { getContract } from 'opnet';
-import { Address } from '@btc-vision/transaction';
-import * as crypto from 'crypto';
-
-import { CLIMldsaLevel, NetworkName, RegistryPluginType } from '../types/index.js';
-import { IPluginPermissions } from '@btc-vision/plugin-sdk';
-import { IPackageRegistry } from '../types/PackageRegistry.js';
-import { getProvider, getRegistryContractAddress } from './provider.js';
-import { getNetwork } from './wallet.js';
-import { loadConfig } from './config.js';
-import { PACKAGE_REGISTRY_ABI } from './PackageRegistry.abi.js';
-
-/**
- * Scope information
- */
-export interface ScopeInfo {
-    exists: boolean;
-    owner: Address;
-    createdAt: bigint;
-}
-
-/**
- * Package information
- */
-export interface PackageInfo {
-    exists: boolean;
-    owner: Address;
-    createdAt: bigint;
-    versionCount: bigint;
-    latestVersion: string;
-}
-
-/**
- * Version information
- */
-export interface VersionInfo {
-    exists: boolean;
-    ipfsCid: string;
-    checksum: Uint8Array;
-    sigHash: Uint8Array;
-    mldsaLevel: number;
-    opnetVersionRange: string;
-    pluginType: number;
-    permissionsHash: Uint8Array;
-    depsHash: Uint8Array;
-    publisher: Address;
-    publishedAt: bigint;
-    deprecated: boolean;
-}
-
-/**
- * Pending transfer information
- */
-export interface PendingTransferInfo {
-    pendingOwner: Address;
-    initiatedAt: bigint;
-}
-
-/**
- * Registry contract cache
- */
-const registryCache = new Map<string, IPackageRegistry>();
-
-/**
- * Get the registry contract instance
- *
- * @param network - Network name (defaults to configured default)
- * @param sender - Optional sender address for write operations
- * @returns Contract instance
- */
-export function getRegistryContract(network?: NetworkName, sender?: Address): IPackageRegistry {
-    const config = loadConfig();
-    const targetNetwork = network || config.defaultNetwork;
-    // Include sender in cache key to handle both read-only and write cases
-    const cacheKey = sender ? `${targetNetwork}:${sender.toHex()}` : targetNetwork;
-
-    const cached = registryCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-
-    const provider = getProvider(targetNetwork);
-    const registryAddress = getRegistryContractAddress(targetNetwork);
-    const bitcoinNetwork = getNetwork(targetNetwork);
-
-    const contract = getContract<IPackageRegistry>(
-        registryAddress,
-        PACKAGE_REGISTRY_ABI,
-        provider,
-        bitcoinNetwork,
-        sender,
-    );
-
-    registryCache.set(cacheKey, contract);
-    return contract;
-}
-
-/**
- * Clear registry contract cache
- */
-export function clearRegistryCache(): void {
-    registryCache.clear();
-}
-
-/**
- * Get scope information
- *
- * @param scopeName - The scope name (without @)
- * @param network - Network name
- * @returns Scope information or null if not found
- */
-export async function getScope(
-    scopeName: string,
-    network?: NetworkName,
-): Promise<ScopeInfo | null> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getScope(scopeName);
-
-    if (!result.properties.exists) {
-        return null;
-    }
-
-    return {
-        exists: result.properties.exists,
-        owner: result.properties.owner,
-        createdAt: result.properties.createdAt,
-    };
-}
-
-/**
- * Get scope owner
- *
- * @param scopeName - The scope name (without @)
- * @param network - Network name
- * @returns Owner address or null if scope doesn't exist
- */
-export async function getScopeOwner(
-    scopeName: string,
-    network?: NetworkName,
-): Promise<Address | null> {
-    const contract = getRegistryContract(network);
-    try {
-        const result = await contract.getScopeOwner(scopeName);
-        return result.properties.owner;
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get package information
- *
- * @param packageName - The package name (with @ for scoped)
- * @param network - Network name
- * @returns Package information or null if not found
- */
-export async function getPackage(
-    packageName: string,
-    network?: NetworkName,
-): Promise<PackageInfo | null> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getPackage(packageName);
-
-    if (!result.properties.exists) {
-        return null;
-    }
-
-    return {
-        exists: result.properties.exists,
-        owner: result.properties.owner,
-        createdAt: result.properties.createdAt,
-        versionCount: result.properties.versionCount,
-        latestVersion: result.properties.latestVersion,
-    };
-}
-
-/**
- * Get package owner
- *
- * @param packageName - The package name
- * @param network - Network name
- * @returns Owner address or null if package doesn't exist
- */
-export async function getPackageOwner(
-    packageName: string,
-    network?: NetworkName,
-): Promise<Address | null> {
-    const contract = getRegistryContract(network);
-    try {
-        const result = await contract.getOwner(packageName);
-        return result.properties.owner;
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get version information
- *
- * @param packageName - The package name
- * @param version - The version string (semver)
- * @param network - Network name
- * @returns Version information or null if not found
- */
-export async function getVersion(
-    packageName: string,
-    version: string,
-    network?: NetworkName,
-): Promise<VersionInfo | null> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getVersion(packageName, version);
-
-    if (!result.properties.exists) {
-        return null;
-    }
-
-    return {
-        exists: result.properties.exists,
-        ipfsCid: result.properties.ipfsCid,
-        checksum: result.properties.checksum,
-        sigHash: result.properties.sigHash,
-        mldsaLevel: result.properties.mldsaLevel,
-        opnetVersionRange: result.properties.opnetVersionRange,
-        pluginType: result.properties.pluginType,
-        permissionsHash: result.properties.permissionsHash,
-        depsHash: result.properties.depsHash,
-        publisher: result.properties.publisher,
-        publishedAt: result.properties.publishedAt,
-        deprecated: result.properties.deprecated,
-    };
-}
-
-/**
- * Check if a version is deprecated
- *
- * @param packageName - The package name
- * @param version - The version string
- * @param network - Network name
- * @returns True if deprecated
- */
-export async function isVersionDeprecated(
-    packageName: string,
-    version: string,
-    network?: NetworkName,
-): Promise<boolean> {
-    const contract = getRegistryContract(network);
-    const result = await contract.isDeprecated(packageName, version);
-    return result.properties.deprecated;
-}
-
-/**
- * Check if a version is immutable (past 72-hour window)
- *
- * @param packageName - The package name
- * @param version - The version string
- * @param network - Network name
- * @returns True if immutable
- */
-export async function isVersionImmutable(
-    packageName: string,
-    version: string,
-    network?: NetworkName,
-): Promise<boolean> {
-    const contract = getRegistryContract(network);
-    const result = await contract.isImmutable(packageName, version);
-    return result.properties.immutable;
-}
-
-/**
- * Get pending package transfer
- *
- * @param packageName - The package name
- * @param network - Network name
- * @returns Pending transfer info or null
- */
-export async function getPendingTransfer(
-    packageName: string,
-    network?: NetworkName,
-): Promise<PendingTransferInfo | null> {
-    const contract = getRegistryContract(network);
-    try {
-        const result = await contract.getPendingTransfer(packageName);
-        const pendingOwner = result.properties.pendingOwner;
-
-        // Check if there's actually a pending transfer (address not zero)
-        if (!pendingOwner || pendingOwner.toString() === '0'.repeat(64)) {
-            return null;
-        }
-
-        return {
-            pendingOwner,
-            initiatedAt: result.properties.initiatedAt,
-        };
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get pending scope transfer
- *
- * @param scopeName - The scope name
- * @param network - Network name
- * @returns Pending transfer info or null
- */
-export async function getPendingScopeTransfer(
-    scopeName: string,
-    network?: NetworkName,
-): Promise<PendingTransferInfo | null> {
-    const contract = getRegistryContract(network);
-    try {
-        const result = await contract.getPendingScopeTransfer(scopeName);
-        const pendingOwner = result.properties.pendingOwner;
-
-        // Check if there's actually a pending transfer (address not zero)
-        if (!pendingOwner || pendingOwner.toString() === '0'.repeat(64)) {
-            return null;
-        }
-
-        return {
-            pendingOwner,
-            initiatedAt: result.properties.initiatedAt,
-        };
-    } catch {
-        return null;
-    }
-}
-
-/**
- * Get treasury address
- *
- * @param network - Network name
- * @returns Treasury address string
- */
-export async function getTreasuryAddress(network?: NetworkName): Promise<string> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getTreasuryAddress();
-    return result.properties.treasuryAddress;
-}
-
-/**
- * Get scope registration price
- *
- * @param network - Network name
- * @returns Price in satoshis
- */
-export async function getScopePrice(network?: NetworkName): Promise<bigint> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getScopePrice();
-    return result.properties.priceSats;
-}
-
-/**
- * Get package registration price
- *
- * @param network - Network name
- * @returns Price in satoshis
- */
-export async function getPackagePrice(network?: NetworkName): Promise<bigint> {
-    const contract = getRegistryContract(network);
-    const result = await contract.getPackagePrice();
-    return result.properties.priceSats;
-}
-
-/**
- * Parse a package name into scope and name
- *
- * @param fullName - Full package name (e.g., "@scope/name" or "name")
- * @returns Object with scope (or null) and name
- */
-export function parsePackageName(fullName: string): { scope: string | null; name: string } {
-    if (fullName.startsWith('@')) {
-        const slashIndex = fullName.indexOf('/');
-        if (slashIndex > 0) {
-            return {
-                scope: fullName.substring(1, slashIndex),
-                name: fullName.substring(slashIndex + 1),
-            };
-        }
-    }
-    return { scope: null, name: fullName };
-}
-
-/**
- * Compute permissions hash from permissions object
- *
- * @param permissions - Plugin permissions
- * @returns SHA-256 hash as Uint8Array
- */
-export function computePermissionsHash(permissions: IPluginPermissions | undefined): Uint8Array {
-    const json = JSON.stringify(permissions);
-    const hash = crypto.createHash('sha256').update(json).digest();
-    return new Uint8Array(hash);
-}
-
-/**
- * Encode dependencies for publishing
- *
- * @param dependencies - Dependencies map { name: version }
- * @returns Encoded dependencies as Uint8Array
- */
-export function encodeDependencies(dependencies: Record<string, string>): Uint8Array {
-    if (Object.keys(dependencies).length === 0) {
-        return new Uint8Array(0);
-    }
-
-    const json = JSON.stringify(dependencies);
-    return new Uint8Array(Buffer.from(json, 'utf-8'));
-}
-
-/**
- * Convert registry MLDSA level (1, 2, 3) to actual level (44, 65, 87)
- *
- * @param registryLevel - Registry level (1, 2, 3)
- * @returns MLDSA level (44, 65, 87)
- */
-export function registryToMldsaLevel(registryLevel: number): CLIMldsaLevel {
-    const levels: Record<number, CLIMldsaLevel> = {
-        1: 44,
-        2: 65,
-        3: 87,
-    };
-    return levels[registryLevel] || 44;
-}
-
-/**
- * Convert MLDSA level (44, 65, 87) to registry level (1, 2, 3)
- *
- * @param mldsaLevel - MLDSA level (44, 65, 87)
- * @returns Registry level (1, 2, 3)
- */
-export function mldsaLevelToRegistry(mldsaLevel: CLIMldsaLevel): number {
-    const levels: Record<CLIMldsaLevel, number> = {
-        44: 1,
-        65: 2,
-        87: 3,
-    };
-    return levels[mldsaLevel] || 1;
-}
-
-/**
- * Convert registry plugin type (1, 2) to string
- *
- * @param registryType - Registry plugin type (1, 2)
- * @returns Plugin type string
- */
-export function registryToPluginType(registryType: number): RegistryPluginType {
-    return registryType === 2 ? 'library' : 'standalone';
-}
-
-/**
- * Convert plugin type string to registry value
- *
- * @param pluginType - Plugin type string
- * @returns Registry plugin type (1, 2)
- */
-export function pluginTypeToRegistry(pluginType: RegistryPluginType): number {
-    return pluginType === 'library' ? 2 : 1;
-}

package/src/lib/transaction.ts

@@ -1,205 +0,0 @@
-/**
- * Transaction helper for OPNet CLI
- *
- * Provides utilities for building and executing registry transactions.
- *
- * @module lib/transaction
- */
-
-import { Address } from '@btc-vision/transaction';
-import { TransactionParameters } from 'opnet';
-import ora, { Ora } from 'ora';
-
-import { CLIWallet, getNetwork } from './wallet.js';
-import { NetworkName } from '../types/index.js';
-import { getProvider } from './provider.js';
-import { PsbtOutputExtended } from '@btc-vision/bitcoin';
-
-/** Default maximum satoshis to spend per transaction */
-export const DEFAULT_MAX_SAT_TO_SPEND = 100_000n;
-
-/** Default fee rate in sat/vbyte */
-export const DEFAULT_FEE_RATE = 6;
-
-/**
- * Build TransactionParameters from a CLIWallet
- *
- * @param wallet - The CLI wallet instance
- * @param network - Target network name
- * @param maxSatToSpend - Maximum satoshis to spend (optional)
- * @param feeRate - Fee rate in sat/vbyte (optional)
- * @param extra
- * @returns TransactionParameters for contract calls
- */
-export function buildTransactionParams(
-    wallet: CLIWallet,
-    network: NetworkName,
-    maxSatToSpend: bigint = DEFAULT_MAX_SAT_TO_SPEND,
-    feeRate: number = DEFAULT_FEE_RATE,
-    extra?: PsbtOutputExtended,
-): TransactionParameters {
-    const bitcoinNetwork = getNetwork(network);
-
-    return {
-        signer: wallet.keypair,
-        mldsaSigner: wallet.mldsaKeypair,
-        refundTo: wallet.p2trAddress,
-        maximumAllowedSatToSpend: maxSatToSpend,
-        network: bitcoinNetwork,
-        feeRate,
-        extraOutputs: extra ? [extra] : undefined,
-    };
-}
-
-/**
- * Get the sender Address from a wallet
- *
- * @param wallet - The CLI wallet
- * @returns Address instance for the wallet
- */
-export function getWalletAddress(wallet: CLIWallet): Address {
-    return wallet.address;
-}
-
-/**
- * Format satoshis for display
- *
- * @param sats - Amount in satoshis
- * @returns Formatted string with BTC equivalent
- */
-export function formatSats(sats: bigint): string {
-    const btc = Number(sats) / 100_000_000;
-    if (btc >= 0.001) {
-        return `${sats} sats (${btc.toFixed(8)} BTC)`;
-    }
-    return `${sats} sats`;
-}
-
-/**
- * Check if wallet has sufficient balance for transaction
- *
- * @param wallet - The CLI wallet
- * @param network - Target network
- * @param minBalance - Minimum required balance in satoshis
- * @returns True if balance is sufficient
- */
-export async function checkBalance(
-    wallet: CLIWallet,
-    network: NetworkName,
-    minBalance: bigint = 10_000n,
-): Promise<{ sufficient: boolean; balance: bigint }> {
-    const provider = getProvider(network);
-    const balance = await provider.getBalance(wallet.p2trAddress);
-
-    return {
-        sufficient: balance >= minBalance,
-        balance,
-    };
-}
-
-/** Default polling interval in milliseconds */
-export const DEFAULT_POLL_INTERVAL = 10_000;
-
-/** Default maximum wait time in milliseconds (10 minutes) */
-export const DEFAULT_MAX_WAIT_TIME = 600_000;
-
-export interface TransactionConfirmationResult {
-    confirmed: boolean;
-    blockNumber?: bigint;
-    revert?: string;
-    error?: string;
-}
-
-/**
- * Wait for a transaction to be confirmed on-chain
- *
- * Polls the transaction status every pollInterval ms until:
- * - The transaction is confirmed (has a blockNumber)
- * - The transaction fails (has a revert)
- * - The maximum wait time is exceeded
- *
- * @param txHash - The transaction hash to wait for
- * @param network - Target network
- * @param options - Optional configuration
- * @returns Transaction confirmation result
- */
-export async function waitForTransactionConfirmation(
-    txHash: string,
-    network: NetworkName,
-    options?: {
-        pollInterval?: number;
-        maxWaitTime?: number;
-        message?: string;
-    },
-): Promise<TransactionConfirmationResult> {
-    const pollInterval = options?.pollInterval ?? DEFAULT_POLL_INTERVAL;
-    const maxWaitTime = options?.maxWaitTime ?? DEFAULT_MAX_WAIT_TIME;
-    const message = options?.message ?? 'Waiting for transaction confirmation';
-
-    const provider = getProvider(network);
-    const startTime = Date.now();
-
-    const spinner: Ora = ora({
-        text: `${message} (0s elapsed)`,
-        spinner: 'dots',
-    }).start();
-
-    const updateSpinnerText = (): void => {
-        const elapsed = Math.floor((Date.now() - startTime) / 1000);
-        spinner.text = `${message} (${elapsed}s elapsed)`;
-    };
-
-    // Update spinner text every second
-    const textUpdateInterval = setInterval(updateSpinnerText, 1000);
-
-    try {
-        while (Date.now() - startTime < maxWaitTime) {
-            try {
-                const tx = await provider.getTransaction(txHash);
-
-                // Check if transaction has a block number (confirmed)
-                if (tx.blockNumber !== undefined && tx.blockNumber !== null) {
-                    const blockNum =
-                        typeof tx.blockNumber === 'bigint'
-                            ? tx.blockNumber
-                            : BigInt(tx.blockNumber);
-                    spinner.succeed(`Transaction confirmed in block ${blockNum}`);
-                    return {
-                        confirmed: true,
-                        blockNumber: blockNum,
-                    };
-                }
-
-                // Check if transaction reverted
-                if (tx.revert) {
-                    spinner.fail(`Transaction reverted: ${tx.revert}`);
-                    return {
-                        confirmed: false,
-                        revert: tx.revert,
-                    };
-                }
-            } catch {
-                // Transaction not found yet, continue polling
-            }
-
-            // Wait before next poll
-            await sleep(pollInterval);
-        }
-
-        // Timeout reached
-        spinner.fail(`Timeout waiting for transaction confirmation`);
-        return {
-            confirmed: false,
-            error: `Transaction not confirmed within ${maxWaitTime / 1000} seconds`,
-        };
-    } finally {
-        clearInterval(textUpdateInterval);
-    }
-}
-
-/**
- * Sleep for a given number of milliseconds
- */
-function sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}