@btc-vision/cli 1.0.0

package/build/types/PackageRegistry.d.ts

@@ -0,0 +1,177 @@
+import { Address } from '@btc-vision/transaction';
+import { CallResult, OPNetEvent, IOP_NETContract } from 'opnet';
+export type TreasuryAddressChangedEvent = {
+    readonly previousAddressHash: bigint;
+    readonly newAddressHash: bigint;
+    readonly timestamp: bigint;
+};
+export type ScopePriceChangedEvent = {
+    readonly oldPrice: bigint;
+    readonly newPrice: bigint;
+    readonly timestamp: bigint;
+};
+export type PackagePriceChangedEvent = {
+    readonly oldPrice: bigint;
+    readonly newPrice: bigint;
+    readonly timestamp: bigint;
+};
+export type ScopeRegisteredEvent = {
+    readonly scopeHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type ScopeTransferInitiatedEvent = {
+    readonly scopeHash: bigint;
+    readonly currentOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type ScopeTransferCompletedEvent = {
+    readonly scopeHash: bigint;
+    readonly previousOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type ScopeTransferCancelledEvent = {
+    readonly scopeHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type PackageRegisteredEvent = {
+    readonly packageHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type VersionPublishedEvent = {
+    readonly packageHash: bigint;
+    readonly versionHash: bigint;
+    readonly publisher: Address;
+    readonly checksum: bigint;
+    readonly timestamp: bigint;
+    readonly mldsaLevel: number;
+    readonly pluginType: number;
+};
+export type VersionDeprecatedEvent = {
+    readonly packageHash: bigint;
+    readonly versionHash: bigint;
+    readonly timestamp: bigint;
+};
+export type VersionUndeprecatedEvent = {
+    readonly packageHash: bigint;
+    readonly versionHash: bigint;
+    readonly timestamp: bigint;
+};
+export type PackageTransferInitiatedEvent = {
+    readonly packageHash: bigint;
+    readonly currentOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type PackageTransferCompletedEvent = {
+    readonly packageHash: bigint;
+    readonly previousOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type PackageTransferCancelledEvent = {
+    readonly packageHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type SetTreasuryAddress = CallResult<{}, OPNetEvent<TreasuryAddressChangedEvent>[]>;
+export type SetScopePrice = CallResult<{}, OPNetEvent<ScopePriceChangedEvent>[]>;
+export type SetPackagePrice = CallResult<{}, OPNetEvent<PackagePriceChangedEvent>[]>;
+export type RegisterScope = CallResult<{}, OPNetEvent<ScopeRegisteredEvent>[]>;
+export type InitiateScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferInitiatedEvent>[]>;
+export type AcceptScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferCompletedEvent>[]>;
+export type CancelScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferCancelledEvent>[]>;
+export type RegisterPackage = CallResult<{}, OPNetEvent<PackageRegisteredEvent>[]>;
+export type PublishVersion = CallResult<{}, OPNetEvent<VersionPublishedEvent>[]>;
+export type DeprecateVersion = CallResult<{}, OPNetEvent<VersionDeprecatedEvent>[]>;
+export type UndeprecateVersion = CallResult<{}, OPNetEvent<VersionUndeprecatedEvent>[]>;
+export type InitiateTransfer = CallResult<{}, OPNetEvent<PackageTransferInitiatedEvent>[]>;
+export type AcceptTransfer = CallResult<{}, OPNetEvent<PackageTransferCompletedEvent>[]>;
+export type CancelTransfer = CallResult<{}, OPNetEvent<PackageTransferCancelledEvent>[]>;
+export type GetScope = CallResult<{
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+}, OPNetEvent<never>[]>;
+export type GetScopeOwner = CallResult<{
+    owner: Address;
+}, OPNetEvent<never>[]>;
+export type GetPackage = CallResult<{
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+    versionCount: bigint;
+    latestVersion: string;
+}, OPNetEvent<never>[]>;
+export type GetOwner = CallResult<{
+    owner: Address;
+}, OPNetEvent<never>[]>;
+export type GetVersion = CallResult<{
+    exists: boolean;
+    ipfsCid: string;
+    checksum: Uint8Array;
+    sigHash: Uint8Array;
+    mldsaLevel: number;
+    opnetVersionRange: string;
+    pluginType: number;
+    permissionsHash: Uint8Array;
+    depsHash: Uint8Array;
+    publisher: Address;
+    publishedAt: bigint;
+    deprecated: boolean;
+}, OPNetEvent<never>[]>;
+export type IsDeprecated = CallResult<{
+    deprecated: boolean;
+}, OPNetEvent<never>[]>;
+export type IsImmutable = CallResult<{
+    immutable: boolean;
+}, OPNetEvent<never>[]>;
+export type GetPendingTransfer = CallResult<{
+    pendingOwner: Address;
+    initiatedAt: bigint;
+}, OPNetEvent<never>[]>;
+export type GetPendingScopeTransfer = CallResult<{
+    pendingOwner: Address;
+    initiatedAt: bigint;
+}, OPNetEvent<never>[]>;
+export type GetTreasuryAddress = CallResult<{
+    treasuryAddress: string;
+}, OPNetEvent<never>[]>;
+export type GetScopePrice = CallResult<{
+    priceSats: bigint;
+}, OPNetEvent<never>[]>;
+export type GetPackagePrice = CallResult<{
+    priceSats: bigint;
+}, OPNetEvent<never>[]>;
+export interface IPackageRegistry extends IOP_NETContract {
+    setTreasuryAddress(treasuryAddress: string): Promise<SetTreasuryAddress>;
+    setScopePrice(priceSats: bigint): Promise<SetScopePrice>;
+    setPackagePrice(priceSats: bigint): Promise<SetPackagePrice>;
+    registerScope(scopeName: string): Promise<RegisterScope>;
+    initiateScopeTransfer(scopeName: string, newOwner: Address): Promise<InitiateScopeTransfer>;
+    acceptScopeTransfer(scopeName: string): Promise<AcceptScopeTransfer>;
+    cancelScopeTransfer(scopeName: string): Promise<CancelScopeTransfer>;
+    registerPackage(packageName: string): Promise<RegisterPackage>;
+    publishVersion(packageName: string, version: string, ipfsCid: string, checksum: Uint8Array, signature: Uint8Array, mldsaLevel: number, opnetVersionRange: string, pluginType: number, permissionsHash: Uint8Array, dependencies: Uint8Array): Promise<PublishVersion>;
+    deprecateVersion(packageName: string, version: string, reason: string): Promise<DeprecateVersion>;
+    undeprecateVersion(packageName: string, version: string): Promise<UndeprecateVersion>;
+    initiateTransfer(packageName: string, newOwner: Address): Promise<InitiateTransfer>;
+    acceptTransfer(packageName: string): Promise<AcceptTransfer>;
+    cancelTransfer(packageName: string): Promise<CancelTransfer>;
+    getScope(scopeName: string): Promise<GetScope>;
+    getScopeOwner(scopeName: string): Promise<GetScopeOwner>;
+    getPackage(packageName: string): Promise<GetPackage>;
+    getOwner(packageName: string): Promise<GetOwner>;
+    getVersion(packageName: string, version: string): Promise<GetVersion>;
+    isDeprecated(packageName: string, version: string): Promise<IsDeprecated>;
+    isImmutable(packageName: string, version: string): Promise<IsImmutable>;
+    getPendingTransfer(packageName: string): Promise<GetPendingTransfer>;
+    getPendingScopeTransfer(scopeName: string): Promise<GetPendingScopeTransfer>;
+    getTreasuryAddress(): Promise<GetTreasuryAddress>;
+    getScopePrice(): Promise<GetScopePrice>;
+    getPackagePrice(): Promise<GetPackagePrice>;
+}

package/build/types/PackageRegistry.js

@@ -0,0 +1 @@
+export {};

package/build/types/index.d.ts

@@ -0,0 +1,30 @@
+import { MLDSALevel } from '@btc-vision/plugin-sdk';
+export type NetworkName = 'mainnet' | 'testnet' | 'regtest';
+export type CLIMldsaLevel = 44 | 65 | 87;
+export interface CLIConfig {
+    defaultNetwork: NetworkName;
+    rpcUrls: Record<NetworkName, string>;
+    ipfsGateway: string;
+    ipfsGateways: string[];
+    ipfsPinningEndpoint: string;
+    ipfsPinningApiKey: string;
+    ipfsPinningAuthHeader: string;
+    registryAddresses: Record<NetworkName, string>;
+    defaultMldsaLevel: CLIMldsaLevel;
+    indexerUrl: string;
+}
+export interface CLICredentials {
+    mnemonic?: string;
+    wif?: string;
+    mldsaPrivateKey?: string;
+    mldsaLevel: CLIMldsaLevel;
+    network: NetworkName;
+}
+export type RegistryPluginType = 'standalone' | 'library';
+export declare function cliLevelToMLDSALevel(level: CLIMldsaLevel): MLDSALevel;
+export declare function mldsaLevelToCLI(level: MLDSALevel): CLIMldsaLevel;
+export declare function registryLevelToCLI(level: number): CLIMldsaLevel;
+export declare function cliLevelToRegistry(level: CLIMldsaLevel): number;
+export declare function getPublicKeySize(level: CLIMldsaLevel): number;
+export declare function getSignatureSize(level: CLIMldsaLevel): number;
+export declare function isValidCLIMldsaLevel(level: number): level is CLIMldsaLevel;

package/build/types/index.js

@@ -0,0 +1,52 @@
+import { MLDSALevel, MLDSA_PUBLIC_KEY_SIZES, MLDSA_SIGNATURE_SIZES } from '@btc-vision/plugin-sdk';
+export function cliLevelToMLDSALevel(level) {
+    switch (level) {
+        case 44:
+            return MLDSALevel.MLDSA44;
+        case 65:
+            return MLDSALevel.MLDSA65;
+        case 87:
+            return MLDSALevel.MLDSA87;
+    }
+}
+export function mldsaLevelToCLI(level) {
+    switch (level) {
+        case MLDSALevel.MLDSA44:
+            return 44;
+        case MLDSALevel.MLDSA65:
+            return 65;
+        case MLDSALevel.MLDSA87:
+            return 87;
+    }
+}
+export function registryLevelToCLI(level) {
+    switch (level) {
+        case 1:
+            return 44;
+        case 2:
+            return 65;
+        case 3:
+            return 87;
+        default:
+            throw new Error(`Invalid registry MLDSA level: ${level}`);
+    }
+}
+export function cliLevelToRegistry(level) {
+    switch (level) {
+        case 44:
+            return 1;
+        case 65:
+            return 2;
+        case 87:
+            return 3;
+    }
+}
+export function getPublicKeySize(level) {
+    return MLDSA_PUBLIC_KEY_SIZES[cliLevelToMLDSALevel(level)];
+}
+export function getSignatureSize(level) {
+    return MLDSA_SIGNATURE_SIZES[cliLevelToMLDSALevel(level)];
+}
+export function isValidCLIMldsaLevel(level) {
+    return level === 44 || level === 65 || level === 87;
+}

package/eslint.config.js

@@ -0,0 +1,41 @@
+// @ts-check
+
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+    eslint.configs.recommended,
+    ...tseslint.configs.strictTypeChecked,
+    {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigDirName: import.meta.dirname,
+            },
+        },
+        rules: {
+            'no-undef': 'off',
+            '@typescript-eslint/no-unused-vars': 'off',
+            'no-empty': 'off',
+            '@typescript-eslint/restrict-template-expressions': 'off',
+            '@typescript-eslint/only-throw-error': 'off',
+            '@typescript-eslint/no-unnecessary-condition': 'off',
+            '@typescript-eslint/unbound-method': 'warn',
+            '@typescript-eslint/no-confusing-void-expression': 'off',
+            '@typescript-eslint/no-extraneous-class': 'off',
+            'no-async-promise-executor': 'off',
+            '@typescript-eslint/no-misused-promises': 'off',
+            '@typescript-eslint/no-unnecessary-type-parameters': 'off',
+            '@typescript-eslint/no-duplicate-enum-values': 'off',
+            'prefer-spread': 'off',
+            '@typescript-eslint/no-empty-object-type': 'off',
+            '@typescript-eslint/no-base-to-string': 'off',
+            '@typescript-eslint/no-dynamic-delete': 'off',
+            '@typescript-eslint/no-redundant-type-constituents': 'off',
+        },
+    },
+    {
+        files: ['**/*.js'],
+        ...tseslint.configs.disableTypeChecked,
+    },
+);

package/gulpfile.js

@@ -0,0 +1,41 @@
+import gulp from 'gulp';
+import gulpcache from 'gulp-cached';
+import gulpClean from 'gulp-clean';
+import gulpESLintNew from 'gulp-eslint-new';
+import logger from 'gulp-logger-new';
+import ts from 'gulp-typescript';
+
+process.on('uncaughtException', function (err) {
+    console.log('Caught exception: ', err);
+});
+
+const tsProject = ts.createProject('tsconfig.json');
+
+function buildESM() {
+    return tsProject
+        .src()
+        .pipe(gulpcache('ts-esm'))
+        .pipe(
+            logger({
+                before: 'Starting...',
+                after: 'Project compiled!',
+                extname: '.js',
+                showChange: true,
+            }),
+        )
+        .pipe(gulpESLintNew())
+        .pipe(gulpESLintNew.format())
+        .pipe(tsProject())
+        .pipe(gulp.dest('build'));
+}
+
+export async function clean() {
+    return gulp.src('./build', { read: false, allowEmpty: true }).pipe(gulpClean());
+}
+
+export const build = buildESM;
+export default build;
+
+export function watch() {
+    gulp.watch(['src/**/*.ts'], gulp.series(buildESM));
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+    "name": "@btc-vision/cli",
+    "version": "1.0.0",
+    "type": "module",
+    "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
+    "author": "OP_NET",
+    "license": "Apache-2.0",
+    "homepage": "https://opnet.org",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/btc-vision/opnet-cli.git"
+    },
+    "bugs": {
+        "url": "https://github.com/btc-vision/opnet-cli/issues"
+    },
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "bin": {
+        "opnet": "./build/index.js"
+    },
+    "exports": {
+        ".": {
+            "import": "./build/index.js",
+            "require": "./build/index.js",
+            "types": "./build/index.d.ts"
+        }
+    },
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
+    "typings": "build/index.d.ts",
+    "module": "build/index.js",
+    "publishConfig": {
+        "access": "public",
+        "tag": "latest"
+    },
+    "scripts": {
+        "build": "gulp build",
+        "watch": "gulp watch",
+        "clean": "gulp clean",
+        "lint": "eslint src/",
+        "format": "prettier --write src/",
+        "start": "node build/index.js",
+        "test": "echo \"Tests not yet implemented\""
+    },
+    "dependencies": {
+        "@btc-vision/bip32": "^6.0.3",
+        "@btc-vision/bitcoin": "^6.4.11",
+        "@btc-vision/logger": "^1.0.0",
+        "@btc-vision/plugin-sdk": "^1.0.0",
+        "@btc-vision/transaction": "^1.7.19",
+        "@inquirer/prompts": "^7.5.3",
+        "bytenode": "^1.5.7",
+        "commander": "^14.0.0",
+        "esbuild": "^0.25.5",
+        "opnet": "^1.7.17",
+        "ora": "^8.2.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.1",
+        "@types/node": "^24.3.0",
+        "eslint": "^9.39.1",
+        "gulp": "^5.0.1",
+        "gulp-cached": "^1.1.1",
+        "gulp-clean": "^0.4.0",
+        "gulp-eslint-new": "^2.4.0",
+        "gulp-logger-new": "^1.0.1",
+        "gulp-typescript": "^6.0.0-alpha.1",
+        "prettier": "^3.6.2",
+        "typescript": "^5.9.2",
+        "typescript-eslint": "^8.39.1"
+    },
+    "keywords": [
+        "opnet",
+        "cli",
+        "plugin",
+        "bitcoin",
+        "typescript",
+        "blockchain",
+        "mldsa",
+        "quantum"
+    ]
+}

package/src/commands/AcceptCommand.ts

@@ -0,0 +1,151 @@
+/**
+ * Accept command - Accept ownership transfer
+ *
+ * @module commands/AcceptCommand
+ */
+
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getPendingScopeTransfer, getPendingTransfer } from '../lib/registry.js';
+import { canSign, loadCredentials } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+import { NetworkName } from '../types/index.js';
+
+interface AcceptOptions {
+    network: string;
+    yes?: boolean;
+}
+
+export class AcceptCommand extends BaseCommand {
+    constructor() {
+        super('accept', 'Accept pending ownership transfer');
+    }
+
+    protected configure(): void {
+        this.command
+            .argument('<name>', 'Package name or @scope')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((name: string, options?: AcceptOptions) =>
+                this.execute(name, options || { network: 'mainnet' }),
+            );
+    }
+
+    private async execute(name: string, options?: AcceptOptions): Promise<void> {
+        try {
+            // 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);
+            }
+            CLIWallet.fromCredentials(credentials);
+            this.logger.success('Wallet loaded');
+
+            const network = (options?.network || 'mainnet') as NetworkName;
+            const isScope = name.startsWith('@') && !name.includes('/');
+
+            // Check for pending transfer
+            this.logger.info('Checking pending transfer...');
+
+            if (isScope) {
+                const scopeName = name.substring(1);
+                const pending = await getPendingScopeTransfer(scopeName, network);
+
+                if (!pending) {
+                    this.logger.warn('No pending transfer');
+                    this.logger.log(`No pending transfer for ${name}.`);
+                    return;
+                }
+
+                this.logger.success('Found pending transfer');
+
+                // Display summary
+                this.logger.log('');
+                this.logger.info('Accept Transfer');
+                this.logger.log('─'.repeat(50));
+                this.logger.log(`Type:     Scope`);
+                this.logger.log(`Name:     ${name}`);
+                this.logger.log(`Network:  ${options?.network}`);
+                this.logger.log('');
+
+                // Confirmation
+                if (!options?.yes) {
+                    const confirmed = await confirm({
+                        message: `Accept ownership of ${name}?`,
+                        default: true,
+                    });
+
+                    if (!confirmed) {
+                        this.logger.warn('Transfer acceptance cancelled.');
+                        return;
+                    }
+                }
+
+                // Execute acceptance
+                this.logger.info('Accepting transfer...');
+                this.logger.warn('Acceptance transaction required.');
+                this.logger.log('Transaction would call: acceptScopeTransfer(');
+                this.logger.log(`  scopeName: "${scopeName}"`);
+                this.logger.log(')');
+            } else {
+                const pending = await getPendingTransfer(name, network);
+
+                if (!pending) {
+                    this.logger.warn('No pending transfer');
+                    this.logger.log(`No pending transfer for ${name}.`);
+                    return;
+                }
+
+                this.logger.success('Found pending transfer');
+
+                // Display summary
+                this.logger.log('');
+                this.logger.info('Accept Transfer');
+                this.logger.log('─'.repeat(50));
+                this.logger.log(`Type:     Package`);
+                this.logger.log(`Name:     ${name}`);
+                this.logger.log(`Network:  ${options?.network}`);
+                this.logger.log('');
+
+                // Confirmation
+                if (!options?.yes) {
+                    const confirmed = await confirm({
+                        message: `Accept ownership of ${name}?`,
+                        default: true,
+                    });
+
+                    if (!confirmed) {
+                        this.logger.warn('Transfer acceptance cancelled.');
+                        return;
+                    }
+                }
+
+                // Execute acceptance
+                this.logger.info('Accepting transfer...');
+                this.logger.warn('Acceptance transaction required.');
+                this.logger.log('Transaction would call: acceptTransfer(');
+                this.logger.log(`  packageName: "${name}"`);
+                this.logger.log(')');
+            }
+
+            this.logger.info('Acceptance (transaction pending)');
+
+            this.logger.log('');
+            this.logger.success('Transfer acceptance submitted!');
+            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log('');
+        } catch (error) {
+            this.logger.fail('Acceptance failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Acceptance cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+
+export const acceptCommand = new AcceptCommand().getCommand();

package/src/commands/BaseCommand.ts

@@ -0,0 +1,59 @@
+/**
+ * Base command class for OPNet CLI
+ *
+ * @module commands/BaseCommand
+ */
+
+import { Command } from 'commander';
+import { Logger } from '@btc-vision/logger';
+
+/**
+ * Abstract base class for all CLI commands
+ */
+export abstract class BaseCommand {
+    protected readonly logger: Logger;
+    protected readonly command: Command;
+
+    constructor(name: string, description: string) {
+        this.logger = new Logger();
+        this.command = new Command(name).description(description);
+        this.configure();
+    }
+
+    /**
+     * Get the configured command instance
+     */
+    public getCommand(): Command {
+        return this.command;
+    }
+
+    /**
+     * Configure the command with options and action
+     */
+    protected abstract configure(): void;
+
+    /**
+     * Format an error message for display
+     */
+    protected formatError(error: unknown): string {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    }
+
+    /**
+     * Exit with error
+     */
+    protected exitWithError(message: string, code: number = 1): never {
+        this.logger.error(message);
+        process.exit(code);
+    }
+
+    /**
+     * Check if user cancelled (for inquirer)
+     */
+    protected isUserCancelled(error: unknown): boolean {
+        return error instanceof Error && error.message.includes('User force closed');
+    }
+}