@btc-vision/cli 1.0.0

package/build/lib/manifest.js

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { validateManifest as sdkValidateManifest, PLUGIN_NAME_REGEX, PLUGIN_MANIFEST_FILENAME, DEFAULT_PERMISSIONS, DEFAULT_RESOURCES, DEFAULT_LIFECYCLE, } from '@btc-vision/plugin-sdk';
+const SCOPED_NAME_PATTERN = /^@[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/;
+export function validatePluginName(name) {
+    const errors = [];
+    if (!name) {
+        errors.push('Name is required');
+        return errors;
+    }
+    if (name.startsWith('@')) {
+        if (!SCOPED_NAME_PATTERN.test(name)) {
+            errors.push('Scoped name must be @scope/name where scope and name are lowercase alphanumeric with hyphens, starting with a letter');
+        }
+    }
+    else {
+        if (!PLUGIN_NAME_REGEX.test(name)) {
+            errors.push('Name must be lowercase alphanumeric with hyphens, starting with a letter');
+        }
+    }
+    if (name.length > 100) {
+        errors.push('Name must be 100 characters or less');
+    }
+    return errors;
+}
+export function validateManifest(manifest) {
+    return sdkValidateManifest(manifest);
+}
+export function validatePermissions(permissions) {
+    const errors = [];
+    if (permissions.database?.enabled) {
+        if (!permissions.database.collections ||
+            !Array.isArray(permissions.database.collections)) {
+            errors.push('database.collections must be an array when database is enabled');
+        }
+    }
+    return errors;
+}
+export function loadManifest(manifestPath) {
+    const resolvedPath = path.resolve(manifestPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Manifest not found: ${resolvedPath}`);
+    }
+    let manifest;
+    try {
+        const content = fs.readFileSync(resolvedPath, 'utf-8');
+        manifest = JSON.parse(content);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse manifest: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const result = validateManifest(manifest);
+    if (!result.valid) {
+        const errorList = result.errors
+            .map((e) => `  - ${e.path}: ${e.message}`)
+            .join('\n');
+        throw new Error(`Invalid manifest:\n${errorList}`);
+    }
+    return manifest;
+}
+export function saveManifest(manifestPath, manifest) {
+    const content = JSON.stringify(manifest, null, 4);
+    fs.writeFileSync(manifestPath, content, 'utf-8');
+}
+export function createManifest(options) {
+    return {
+        name: options.name,
+        version: '1.0.0',
+        opnetVersion: '^1.0.0',
+        main: 'dist/index.jsc',
+        target: 'bytenode',
+        type: 'plugin',
+        checksum: '',
+        author: {
+            name: options.author,
+            email: options.email,
+        },
+        description: options.description,
+        pluginType: options.pluginType,
+        permissions: DEFAULT_PERMISSIONS,
+        resources: DEFAULT_RESOURCES,
+        lifecycle: DEFAULT_LIFECYCLE,
+        dependencies: {},
+    };
+}
+export function getManifestPath(dir = process.cwd()) {
+    return path.join(dir, PLUGIN_MANIFEST_FILENAME);
+}

package/build/lib/provider.d.ts

@@ -0,0 +1,9 @@
+import { JSONRpcProvider } from 'opnet';
+import { NetworkName } from '../types/index.js';
+export declare function getProvider(network?: NetworkName): JSONRpcProvider;
+export declare function clearProviderCache(): void;
+export declare function getRegistryContractAddress(network?: NetworkName): string;
+export declare function checkConnection(network?: NetworkName): Promise<boolean>;
+export declare function getBlockNumber(network?: NetworkName): Promise<bigint>;
+export declare function getBalance(address: string, network?: NetworkName): Promise<bigint>;
+export declare function broadcastTransaction(rawTx: string, network?: NetworkName, isPsbt?: boolean): Promise<string>;

package/build/lib/provider.js

@@ -0,0 +1,48 @@
+import { JSONRpcProvider } from 'opnet';
+import { getRpcUrl, getRegistryAddress, loadConfig } from './config.js';
+import { getNetwork } from './wallet.js';
+const DEFAULT_TIMEOUT = 30000;
+const providerCache = new Map();
+export function getProvider(network) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    const rpcUrl = getRpcUrl(targetNetwork);
+    const cacheKey = `${targetNetwork}:${rpcUrl}`;
+    const cached = providerCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const bitcoinNetwork = getNetwork(targetNetwork);
+    const provider = new JSONRpcProvider(rpcUrl, bitcoinNetwork, DEFAULT_TIMEOUT);
+    providerCache.set(cacheKey, provider);
+    return provider;
+}
+export function clearProviderCache() {
+    providerCache.clear();
+}
+export function getRegistryContractAddress(network) {
+    return getRegistryAddress(network);
+}
+export async function checkConnection(network) {
+    try {
+        const provider = getProvider(network);
+        await provider.getBlockNumber();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getBlockNumber(network) {
+    const provider = getProvider(network);
+    return provider.getBlockNumber();
+}
+export async function getBalance(address, network) {
+    const provider = getProvider(network);
+    return provider.getBalance(address);
+}
+export async function broadcastTransaction(rawTx, network, isPsbt = false) {
+    const provider = getProvider(network);
+    const result = await provider.sendRawTransaction(rawTx, isPsbt);
+    return result.result ?? '';
+}

package/build/lib/registry.d.ts

@@ -0,0 +1,58 @@
+import { Address } from '@btc-vision/transaction';
+import { NetworkName, CLIMldsaLevel, RegistryPluginType } from '../types/index.js';
+import { IPluginPermissions } from '@btc-vision/plugin-sdk';
+import { IPackageRegistry } from '../types/PackageRegistry.js';
+export interface ScopeInfo {
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+}
+export interface PackageInfo {
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+    versionCount: bigint;
+    latestVersion: string;
+}
+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;
+}
+export interface PendingTransferInfo {
+    pendingOwner: Address;
+    initiatedAt: bigint;
+}
+export declare function getRegistryContract(network?: NetworkName): IPackageRegistry;
+export declare function clearRegistryCache(): void;
+export declare function getScope(scopeName: string, network?: NetworkName): Promise<ScopeInfo | null>;
+export declare function getScopeOwner(scopeName: string, network?: NetworkName): Promise<Address | null>;
+export declare function getPackage(packageName: string, network?: NetworkName): Promise<PackageInfo | null>;
+export declare function getPackageOwner(packageName: string, network?: NetworkName): Promise<Address | null>;
+export declare function getVersion(packageName: string, version: string, network?: NetworkName): Promise<VersionInfo | null>;
+export declare function isVersionDeprecated(packageName: string, version: string, network?: NetworkName): Promise<boolean>;
+export declare function isVersionImmutable(packageName: string, version: string, network?: NetworkName): Promise<boolean>;
+export declare function getPendingTransfer(packageName: string, network?: NetworkName): Promise<PendingTransferInfo | null>;
+export declare function getPendingScopeTransfer(scopeName: string, network?: NetworkName): Promise<PendingTransferInfo | null>;
+export declare function getTreasuryAddress(network?: NetworkName): Promise<string>;
+export declare function getScopePrice(network?: NetworkName): Promise<bigint>;
+export declare function getPackagePrice(network?: NetworkName): Promise<bigint>;
+export declare function parsePackageName(fullName: string): {
+    scope: string | null;
+    name: string;
+};
+export declare function computePermissionsHash(permissions: IPluginPermissions | undefined): Uint8Array;
+export declare function encodeDependencies(dependencies: Record<string, string>): Uint8Array;
+export declare function registryToMldsaLevel(registryLevel: number): CLIMldsaLevel;
+export declare function mldsaLevelToRegistry(mldsaLevel: CLIMldsaLevel): number;
+export declare function registryToPluginType(registryType: number): RegistryPluginType;
+export declare function pluginTypeToRegistry(pluginType: RegistryPluginType): number;

package/build/lib/registry.js

@@ -0,0 +1,197 @@
+import { getContract } from 'opnet';
+import * as crypto from 'crypto';
+import { getProvider, getRegistryContractAddress } from './provider.js';
+import { getNetwork } from './wallet.js';
+import { loadConfig } from './config.js';
+import { PACKAGE_REGISTRY_ABI } from './PackageRegistry.abi.js';
+const registryCache = new Map();
+export function getRegistryContract(network) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    const cacheKey = 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(registryAddress, PACKAGE_REGISTRY_ABI, provider, bitcoinNetwork);
+    registryCache.set(cacheKey, contract);
+    return contract;
+}
+export function clearRegistryCache() {
+    registryCache.clear();
+}
+export async function getScope(scopeName, network) {
+    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,
+    };
+}
+export async function getScopeOwner(scopeName, network) {
+    const contract = getRegistryContract(network);
+    try {
+        const result = await contract.getScopeOwner(scopeName);
+        return result.properties.owner;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPackage(packageName, network) {
+    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,
+    };
+}
+export async function getPackageOwner(packageName, network) {
+    const contract = getRegistryContract(network);
+    try {
+        const result = await contract.getOwner(packageName);
+        return result.properties.owner;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getVersion(packageName, version, network) {
+    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,
+    };
+}
+export async function isVersionDeprecated(packageName, version, network) {
+    const contract = getRegistryContract(network);
+    const result = await contract.isDeprecated(packageName, version);
+    return result.properties.deprecated;
+}
+export async function isVersionImmutable(packageName, version, network) {
+    const contract = getRegistryContract(network);
+    const result = await contract.isImmutable(packageName, version);
+    return result.properties.immutable;
+}
+export async function getPendingTransfer(packageName, network) {
+    const contract = getRegistryContract(network);
+    try {
+        const result = await contract.getPendingTransfer(packageName);
+        const pendingOwner = result.properties.pendingOwner;
+        if (!pendingOwner || pendingOwner.toString() === '0'.repeat(64)) {
+            return null;
+        }
+        return {
+            pendingOwner,
+            initiatedAt: result.properties.initiatedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPendingScopeTransfer(scopeName, network) {
+    const contract = getRegistryContract(network);
+    try {
+        const result = await contract.getPendingScopeTransfer(scopeName);
+        const pendingOwner = result.properties.pendingOwner;
+        if (!pendingOwner || pendingOwner.toString() === '0'.repeat(64)) {
+            return null;
+        }
+        return {
+            pendingOwner,
+            initiatedAt: result.properties.initiatedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getTreasuryAddress(network) {
+    const contract = getRegistryContract(network);
+    const result = await contract.getTreasuryAddress();
+    return result.properties.treasuryAddress;
+}
+export async function getScopePrice(network) {
+    const contract = getRegistryContract(network);
+    const result = await contract.getScopePrice();
+    return result.properties.priceSats;
+}
+export async function getPackagePrice(network) {
+    const contract = getRegistryContract(network);
+    const result = await contract.getPackagePrice();
+    return result.properties.priceSats;
+}
+export function parsePackageName(fullName) {
+    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 };
+}
+export function computePermissionsHash(permissions) {
+    const json = JSON.stringify(permissions);
+    const hash = crypto.createHash('sha256').update(json).digest();
+    return new Uint8Array(hash);
+}
+export function encodeDependencies(dependencies) {
+    if (Object.keys(dependencies).length === 0) {
+        return new Uint8Array(0);
+    }
+    const json = JSON.stringify(dependencies);
+    return new Uint8Array(Buffer.from(json, 'utf-8'));
+}
+export function registryToMldsaLevel(registryLevel) {
+    const levels = {
+        1: 44,
+        2: 65,
+        3: 87,
+    };
+    return levels[registryLevel] || 44;
+}
+export function mldsaLevelToRegistry(mldsaLevel) {
+    const levels = {
+        44: 1,
+        65: 2,
+        87: 3,
+    };
+    return levels[mldsaLevel] || 1;
+}
+export function registryToPluginType(registryType) {
+    return registryType === 2 ? 'library' : 'standalone';
+}
+export function pluginTypeToRegistry(pluginType) {
+    return pluginType === 'library' ? 2 : 1;
+}

package/build/lib/wallet.d.ts

@@ -0,0 +1,32 @@
+import { Network } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+import { Wallet, EcKeyPair } from '@btc-vision/transaction';
+import { CLICredentials, NetworkName, CLIMldsaLevel } from '../types/index.js';
+export declare function getNetwork(networkName: NetworkName): Network;
+export declare function getMLDSASecurityLevel(level: CLIMldsaLevel): MLDSASecurityLevel;
+export declare class CLIWallet {
+    private readonly wallet;
+    private readonly network;
+    private readonly mldsaLevel;
+    private constructor();
+    static fromCredentials(credentials: CLICredentials): CLIWallet;
+    static load(): CLIWallet;
+    get p2trAddress(): string;
+    get underlyingWallet(): Wallet;
+    get keypair(): EcKeyPair;
+    get mldsaKeypair(): EcKeyPair;
+    get mldsaPublicKey(): Buffer;
+    get mldsaPublicKeyHash(): string;
+    get securityLevel(): CLIMldsaLevel;
+    get walletNetwork(): Network;
+    signMLDSA(data: Buffer): Buffer;
+    verifyMLDSA(data: Buffer, signature: Buffer): boolean;
+    static verifyMLDSA(data: Buffer, signature: Buffer, publicKey: Buffer, level: CLIMldsaLevel): boolean;
+}
+export declare function generateMLDSAKeypair(level: CLIMldsaLevel): {
+    privateKey: Buffer;
+    publicKey: Buffer;
+};
+export declare function computePublicKeyHash(publicKey: Buffer): string;
+export declare function validateMnemonic(phrase: string): boolean;
+export declare function generateMnemonic(): string;

package/build/lib/wallet.js

@@ -0,0 +1,114 @@
+import { networks } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel, QuantumBIP32Factory } from '@btc-vision/bip32';
+import { Mnemonic, Wallet, EcKeyPair, MessageSigner } from '@btc-vision/transaction';
+import * as crypto from 'crypto';
+import { loadCredentials, canSign } from './credentials.js';
+export function getNetwork(networkName) {
+    switch (networkName) {
+        case 'mainnet':
+            return networks.bitcoin;
+        case 'testnet':
+            return networks.testnet;
+        case 'regtest':
+            return networks.regtest;
+    }
+}
+export function getMLDSASecurityLevel(level) {
+    switch (level) {
+        case 44:
+            return MLDSASecurityLevel.LEVEL2;
+        case 65:
+            return MLDSASecurityLevel.LEVEL3;
+        case 87:
+            return MLDSASecurityLevel.LEVEL5;
+    }
+}
+export class CLIWallet {
+    wallet;
+    network;
+    mldsaLevel;
+    constructor(wallet, network, mldsaLevel) {
+        this.wallet = wallet;
+        this.network = network;
+        this.mldsaLevel = mldsaLevel;
+    }
+    static fromCredentials(credentials) {
+        const network = getNetwork(credentials.network);
+        const securityLevel = getMLDSASecurityLevel(credentials.mldsaLevel);
+        if (credentials.mnemonic) {
+            const mnemonic = new Mnemonic(credentials.mnemonic, '', network, securityLevel);
+            const wallet = mnemonic.deriveUnisat();
+            return new CLIWallet(wallet, network, credentials.mldsaLevel);
+        }
+        if (credentials.wif && credentials.mldsaPrivateKey) {
+            const wallet = Wallet.fromWif(credentials.wif, credentials.mldsaPrivateKey, network, securityLevel);
+            return new CLIWallet(wallet, network, credentials.mldsaLevel);
+        }
+        throw new Error('Invalid credentials: requires either mnemonic or both WIF and MLDSA key');
+    }
+    static load() {
+        const credentials = loadCredentials();
+        if (!credentials) {
+            throw new Error('No credentials found. Run `opnet login` to configure your wallet.');
+        }
+        if (!canSign(credentials)) {
+            throw new Error('Credentials incomplete for signing. Run `opnet login` to reconfigure.');
+        }
+        return CLIWallet.fromCredentials(credentials);
+    }
+    get p2trAddress() {
+        return this.wallet.p2tr;
+    }
+    get underlyingWallet() {
+        return this.wallet;
+    }
+    get keypair() {
+        return this.wallet.keypair;
+    }
+    get mldsaKeypair() {
+        return this.wallet.mldsaKeypair;
+    }
+    get mldsaPublicKey() {
+        return Buffer.from(this.wallet.mldsaKeypair.publicKey);
+    }
+    get mldsaPublicKeyHash() {
+        const hash = crypto.createHash('sha256').update(this.mldsaPublicKey).digest();
+        return hash.toString('hex');
+    }
+    get securityLevel() {
+        return this.mldsaLevel;
+    }
+    get walletNetwork() {
+        return this.network;
+    }
+    signMLDSA(data) {
+        const result = MessageSigner.signMLDSAMessage(this.wallet.mldsaKeypair, data);
+        return Buffer.from(result.signature);
+    }
+    verifyMLDSA(data, signature) {
+        return MessageSigner.verifyMLDSASignature(this.wallet.mldsaKeypair, data, signature);
+    }
+    static verifyMLDSA(data, signature, publicKey, level) {
+        const securityLevel = getMLDSASecurityLevel(level);
+        const dummyChainCode = new Uint8Array(32);
+        const keypair = QuantumBIP32Factory.fromPublicKey(publicKey, dummyChainCode, networks.bitcoin, securityLevel);
+        return keypair.verify(data, signature);
+    }
+}
+export function generateMLDSAKeypair(level) {
+    const securityLevel = getMLDSASecurityLevel(level);
+    const keypair = EcKeyPair.generateQuantumKeyPair(securityLevel);
+    return {
+        privateKey: Buffer.from(keypair.privateKey),
+        publicKey: Buffer.from(keypair.publicKey),
+    };
+}
+export function computePublicKeyHash(publicKey) {
+    return crypto.createHash('sha256').update(publicKey).digest('hex');
+}
+export function validateMnemonic(phrase) {
+    return Mnemonic.validate(phrase);
+}
+export function generateMnemonic() {
+    return Mnemonic.generatePhrase();
+}