@btc-vision/cli 1.0.0

package/src/lib/wallet.ts

@@ -0,0 +1,271 @@
+/**
+ * Wallet operations for OPNet CLI
+ *
+ * Wraps @btc-vision/transaction Mnemonic and Wallet classes for CLI operations
+ *
+ * @module lib/wallet
+ */
+
+import { Network, networks } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel, QuantumBIP32Factory } from '@btc-vision/bip32';
+import { EcKeyPair, MessageSigner, Mnemonic, Wallet } from '@btc-vision/transaction';
+import * as crypto from 'crypto';
+import { CLICredentials, CLIMldsaLevel, NetworkName } from '../types/index.js';
+import { canSign, loadCredentials } from './credentials.js';
+
+/**
+ * Convert CLI network name to bitcoin-js Network object
+ */
+export function getNetwork(networkName: NetworkName): Network {
+    switch (networkName) {
+        case 'mainnet':
+            return networks.bitcoin;
+        case 'testnet':
+            return networks.testnet;
+        case 'regtest':
+            return networks.regtest;
+    }
+}
+
+/**
+ * Convert CLI MLDSA level to SDK MLDSASecurityLevel enum
+ */
+export function getMLDSASecurityLevel(level: CLIMldsaLevel): MLDSASecurityLevel {
+    switch (level) {
+        case 44:
+            return MLDSASecurityLevel.LEVEL2;
+        case 65:
+            return MLDSASecurityLevel.LEVEL3;
+        case 87:
+            return MLDSASecurityLevel.LEVEL5;
+    }
+}
+
+/**
+ * Wallet wrapper that provides a unified interface for CLI operations
+ */
+export class CLIWallet {
+    private readonly wallet: Wallet;
+    private readonly network: Network;
+    private readonly mldsaLevel: CLIMldsaLevel;
+
+    private constructor(wallet: Wallet, network: Network, mldsaLevel: CLIMldsaLevel) {
+        this.wallet = wallet;
+        this.network = network;
+        this.mldsaLevel = mldsaLevel;
+    }
+
+    /**
+     * Get the P2TR (taproot) address
+     */
+    get p2trAddress(): string {
+        return this.wallet.p2tr;
+    }
+
+    /**
+     * Get the underlying Wallet instance
+     */
+    get underlyingWallet(): Wallet {
+        return this.wallet;
+    }
+
+    /**
+     * Get the Bitcoin keypair for classical signing
+     */
+    get keypair(): EcKeyPair {
+        return this.wallet.keypair;
+    }
+
+    /**
+     * Get the MLDSA keypair for quantum-resistant signing
+     */
+    get mldsaKeypair(): EcKeyPair {
+        return this.wallet.mldsaKeypair;
+    }
+
+    /**
+     * Get the MLDSA public key
+     */
+    get mldsaPublicKey(): Buffer {
+        return Buffer.from(this.wallet.mldsaKeypair.publicKey);
+    }
+
+    /**
+     * Get the MLDSA public key hash (SHA-256)
+     */
+    get mldsaPublicKeyHash(): string {
+        const hash = crypto.createHash('sha256').update(this.mldsaPublicKey).digest();
+        return hash.toString('hex');
+    }
+
+    /**
+     * Get the current MLDSA security level
+     */
+    get securityLevel(): CLIMldsaLevel {
+        return this.mldsaLevel;
+    }
+
+    /**
+     * Get the network this wallet is configured for
+     */
+    get walletNetwork(): Network {
+        return this.network;
+    }
+
+    /**
+     * Create a wallet from credentials
+     *
+     * @param credentials - The credentials to use
+     * @returns A CLIWallet instance
+     */
+    static fromCredentials(credentials: CLICredentials): CLIWallet {
+        const network = getNetwork(credentials.network);
+        const securityLevel = getMLDSASecurityLevel(credentials.mldsaLevel);
+
+        if (credentials.mnemonic) {
+            // Primary method: derive from mnemonic using UniSat derivation
+            const mnemonic = new Mnemonic(
+                credentials.mnemonic,
+                '', // passphrase
+                network,
+                securityLevel,
+            );
+            // Use UniSat-compatible derivation with P2TR (Taproot) address type
+            const wallet = mnemonic.deriveUnisat();
+            return new CLIWallet(wallet, network, credentials.mldsaLevel);
+        }
+
+        if (credentials.wif && credentials.mldsaPrivateKey) {
+            // Advanced method: use WIF + standalone MLDSA key
+            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');
+    }
+
+    /**
+     * Load wallet from stored credentials
+     *
+     * @returns CLIWallet instance or throws if no valid credentials
+     */
+    static load(): CLIWallet {
+        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);
+    }
+
+    /**
+     * Verify an MLDSA signature using a public key buffer
+     *
+     * @param data - The original data that was signed
+     * @param signature - The signature to verify
+     * @param publicKey - The MLDSA public key buffer
+     * @param level - The MLDSA security level
+     * @returns True if the signature is valid
+     */
+    static verifyMLDSA(
+        data: Buffer,
+        signature: Buffer,
+        publicKey: Buffer,
+        level: CLIMldsaLevel,
+    ): boolean {
+        const securityLevel = getMLDSASecurityLevel(level);
+        // Create a dummy chain code (not needed for verification)
+        const dummyChainCode = new Uint8Array(32);
+        // Create a public-key-only keypair for verification
+        const keypair = QuantumBIP32Factory.fromPublicKey(
+            publicKey,
+            dummyChainCode,
+            networks.bitcoin, // Network doesn't matter for signature verification
+            securityLevel,
+        );
+        // Verify signature directly using the keypair
+        return keypair.verify(data, signature);
+    }
+
+    /**
+     * Sign data using MLDSA
+     *
+     * @param data - The data to sign (typically a SHA-256 hash)
+     * @returns The MLDSA signature
+     */
+    signMLDSA(data: Buffer): Buffer {
+        const result = MessageSigner.signMLDSAMessage(this.wallet.mldsaKeypair, data);
+        return Buffer.from(result.signature);
+    }
+
+    /**
+     * Verify an MLDSA signature using this wallet's keypair
+     *
+     * @param data - The original data that was signed
+     * @param signature - The signature to verify
+     * @returns True if the signature is valid
+     */
+    verifyMLDSA(data: Buffer, signature: Buffer): boolean {
+        return MessageSigner.verifyMLDSASignature(this.wallet.mldsaKeypair, data, signature);
+    }
+}
+
+/**
+ * Generate a standalone MLDSA keypair
+ *
+ * @param level - The MLDSA security level
+ * @returns Object containing privateKey and publicKey buffers
+ */
+export function generateMLDSAKeypair(level: CLIMldsaLevel): {
+    privateKey: Buffer;
+    publicKey: Buffer;
+} {
+    const securityLevel = getMLDSASecurityLevel(level);
+    const keypair = EcKeyPair.generateQuantumKeyPair(securityLevel);
+
+    return {
+        privateKey: Buffer.from(keypair.privateKey),
+        publicKey: Buffer.from(keypair.publicKey),
+    };
+}
+
+/**
+ * Compute SHA-256 hash of a public key
+ *
+ * @param publicKey - The public key buffer
+ * @returns Hex-encoded SHA-256 hash
+ */
+export function computePublicKeyHash(publicKey: Buffer): string {
+    return crypto.createHash('sha256').update(publicKey).digest('hex');
+}
+
+/**
+ * Validate a BIP-39 mnemonic phrase
+ *
+ * @param phrase - The mnemonic phrase to validate
+ * @returns True if the phrase is valid
+ */
+export function validateMnemonic(phrase: string): boolean {
+    return Mnemonic.validate(phrase);
+}
+
+/**
+ * Generate a new BIP-39 mnemonic phrase
+ *
+ * @returns A new 24-word mnemonic phrase
+ */
+export function generateMnemonic(): string {
+    return Mnemonic.generatePhrase();
+}

package/src/types/PackageRegistry.ts

@@ -0,0 +1,344 @@
+import { Address } from '@btc-vision/transaction';
+import { CallResult, IOP_NETContract, OPNetEvent } from 'opnet';
+
+// ------------------------------------------------------------------
+// Event Definitions
+// ------------------------------------------------------------------
+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;
+};
+
+// ------------------------------------------------------------------
+// Call Results
+// ------------------------------------------------------------------
+
+/**
+ * @description Represents the result of the setTreasuryAddress function call.
+ */
+export type SetTreasuryAddress = CallResult<{}, OPNetEvent<TreasuryAddressChangedEvent>[]>;
+
+/**
+ * @description Represents the result of the setScopePrice function call.
+ */
+export type SetScopePrice = CallResult<{}, OPNetEvent<ScopePriceChangedEvent>[]>;
+
+/**
+ * @description Represents the result of the setPackagePrice function call.
+ */
+export type SetPackagePrice = CallResult<{}, OPNetEvent<PackagePriceChangedEvent>[]>;
+
+/**
+ * @description Represents the result of the registerScope function call.
+ */
+export type RegisterScope = CallResult<{}, OPNetEvent<ScopeRegisteredEvent>[]>;
+
+/**
+ * @description Represents the result of the initiateScopeTransfer function call.
+ */
+export type InitiateScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferInitiatedEvent>[]>;
+
+/**
+ * @description Represents the result of the acceptScopeTransfer function call.
+ */
+export type AcceptScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferCompletedEvent>[]>;
+
+/**
+ * @description Represents the result of the cancelScopeTransfer function call.
+ */
+export type CancelScopeTransfer = CallResult<{}, OPNetEvent<ScopeTransferCancelledEvent>[]>;
+
+/**
+ * @description Represents the result of the registerPackage function call.
+ */
+export type RegisterPackage = CallResult<{}, OPNetEvent<PackageRegisteredEvent>[]>;
+
+/**
+ * @description Represents the result of the publishVersion function call.
+ */
+export type PublishVersion = CallResult<{}, OPNetEvent<VersionPublishedEvent>[]>;
+
+/**
+ * @description Represents the result of the deprecateVersion function call.
+ */
+export type DeprecateVersion = CallResult<{}, OPNetEvent<VersionDeprecatedEvent>[]>;
+
+/**
+ * @description Represents the result of the undeprecateVersion function call.
+ */
+export type UndeprecateVersion = CallResult<{}, OPNetEvent<VersionUndeprecatedEvent>[]>;
+
+/**
+ * @description Represents the result of the initiateTransfer function call.
+ */
+export type InitiateTransfer = CallResult<{}, OPNetEvent<PackageTransferInitiatedEvent>[]>;
+
+/**
+ * @description Represents the result of the acceptTransfer function call.
+ */
+export type AcceptTransfer = CallResult<{}, OPNetEvent<PackageTransferCompletedEvent>[]>;
+
+/**
+ * @description Represents the result of the cancelTransfer function call.
+ */
+export type CancelTransfer = CallResult<{}, OPNetEvent<PackageTransferCancelledEvent>[]>;
+
+/**
+ * @description Represents the result of the getScope function call.
+ */
+export type GetScope = CallResult<
+    {
+        exists: boolean;
+        owner: Address;
+        createdAt: bigint;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getScopeOwner function call.
+ */
+export type GetScopeOwner = CallResult<
+    {
+        owner: Address;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getPackage function call.
+ */
+export type GetPackage = CallResult<
+    {
+        exists: boolean;
+        owner: Address;
+        createdAt: bigint;
+        versionCount: bigint;
+        latestVersion: string;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getOwner function call.
+ */
+export type GetOwner = CallResult<
+    {
+        owner: Address;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getVersion function call.
+ */
+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>[]
+>;
+
+/**
+ * @description Represents the result of the isDeprecated function call.
+ */
+export type IsDeprecated = CallResult<
+    {
+        deprecated: boolean;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the isImmutable function call.
+ */
+export type IsImmutable = CallResult<
+    {
+        immutable: boolean;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getPendingTransfer function call.
+ */
+export type GetPendingTransfer = CallResult<
+    {
+        pendingOwner: Address;
+        initiatedAt: bigint;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getPendingScopeTransfer function call.
+ */
+export type GetPendingScopeTransfer = CallResult<
+    {
+        pendingOwner: Address;
+        initiatedAt: bigint;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getTreasuryAddress function call.
+ */
+export type GetTreasuryAddress = CallResult<
+    {
+        treasuryAddress: string;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getScopePrice function call.
+ */
+export type GetScopePrice = CallResult<
+    {
+        priceSats: bigint;
+    },
+    OPNetEvent<never>[]
+>;
+
+/**
+ * @description Represents the result of the getPackagePrice function call.
+ */
+export type GetPackagePrice = CallResult<
+    {
+        priceSats: bigint;
+    },
+    OPNetEvent<never>[]
+>;
+
+// ------------------------------------------------------------------
+// IPackageRegistry
+// ------------------------------------------------------------------
+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>;
+}