@btc-vision/cli 1.0.2 → 1.0.3

package/build/lib/transaction.d.ts

@@ -0,0 +1,27 @@
+import { Address } from '@btc-vision/transaction';
+import { TransactionParameters } from 'opnet';
+import { CLIWallet } from './wallet.js';
+import { NetworkName } from '../types/index.js';
+import { PsbtOutputExtended } from '@btc-vision/bitcoin';
+export declare const DEFAULT_MAX_SAT_TO_SPEND = 100000n;
+export declare const DEFAULT_FEE_RATE = 6;
+export declare function buildTransactionParams(wallet: CLIWallet, network: NetworkName, maxSatToSpend?: bigint, feeRate?: number, extra?: PsbtOutputExtended): TransactionParameters;
+export declare function getWalletAddress(wallet: CLIWallet): Address;
+export declare function formatSats(sats: bigint): string;
+export declare function checkBalance(wallet: CLIWallet, network: NetworkName, minBalance?: bigint): Promise<{
+    sufficient: boolean;
+    balance: bigint;
+}>;
+export declare const DEFAULT_POLL_INTERVAL = 10000;
+export declare const DEFAULT_MAX_WAIT_TIME = 600000;
+export interface TransactionConfirmationResult {
+    confirmed: boolean;
+    blockNumber?: bigint;
+    revert?: string;
+    error?: string;
+}
+export declare function waitForTransactionConfirmation(txHash: string, network: NetworkName, options?: {
+    pollInterval?: number;
+    maxWaitTime?: number;
+    message?: string;
+}): Promise<TransactionConfirmationResult>;

package/build/lib/transaction.js

@@ -0,0 +1,91 @@
+import ora from 'ora';
+import { getNetwork } from './wallet.js';
+import { getProvider } from './provider.js';
+export const DEFAULT_MAX_SAT_TO_SPEND = 100000n;
+export const DEFAULT_FEE_RATE = 6;
+export function buildTransactionParams(wallet, network, maxSatToSpend = DEFAULT_MAX_SAT_TO_SPEND, feeRate = DEFAULT_FEE_RATE, extra) {
+    const bitcoinNetwork = getNetwork(network);
+    return {
+        signer: wallet.keypair,
+        mldsaSigner: wallet.mldsaKeypair,
+        refundTo: wallet.p2trAddress,
+        maximumAllowedSatToSpend: maxSatToSpend,
+        network: bitcoinNetwork,
+        feeRate,
+        extraOutputs: extra ? [extra] : undefined,
+    };
+}
+export function getWalletAddress(wallet) {
+    return wallet.address;
+}
+export function formatSats(sats) {
+    const btc = Number(sats) / 100_000_000;
+    if (btc >= 0.001) {
+        return `${sats} sats (${btc.toFixed(8)} BTC)`;
+    }
+    return `${sats} sats`;
+}
+export async function checkBalance(wallet, network, minBalance = 10000n) {
+    const provider = getProvider(network);
+    const balance = await provider.getBalance(wallet.p2trAddress);
+    return {
+        sufficient: balance >= minBalance,
+        balance,
+    };
+}
+export const DEFAULT_POLL_INTERVAL = 10_000;
+export const DEFAULT_MAX_WAIT_TIME = 600_000;
+export async function waitForTransactionConfirmation(txHash, network, options) {
+    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({
+        text: `${message} (0s elapsed)`,
+        spinner: 'dots',
+    }).start();
+    const updateSpinnerText = () => {
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        spinner.text = `${message} (${elapsed}s elapsed)`;
+    };
+    const textUpdateInterval = setInterval(updateSpinnerText, 1000);
+    try {
+        while (Date.now() - startTime < maxWaitTime) {
+            try {
+                const tx = await provider.getTransaction(txHash);
+                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,
+                    };
+                }
+                if (tx.revert) {
+                    spinner.fail(`Transaction reverted: ${tx.revert}`);
+                    return {
+                        confirmed: false,
+                        revert: tx.revert,
+                    };
+                }
+            }
+            catch {
+            }
+            await sleep(pollInterval);
+        }
+        spinner.fail(`Timeout waiting for transaction confirmation`);
+        return {
+            confirmed: false,
+            error: `Transaction not confirmed within ${maxWaitTime / 1000} seconds`,
+        };
+    }
+    finally {
+        clearInterval(textUpdateInterval);
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/build/lib/wallet.d.ts

@@ -1,7 +1,8 @@
-import { Network } from '@btc-vision/bitcoin';
-import { MLDSASecurityLevel } from '@btc-vision/bip32';
-import { EcKeyPair, Wallet } from '@btc-vision/transaction';
+import { Network, Signer } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-vision/bip32';
+import { Address } from '@btc-vision/transaction';
 import { CLICredentials, CLIMldsaLevel, NetworkName } from '../types/index.js';
+import { ECPairInterface } from 'ecpair';
 export declare function getNetwork(networkName: NetworkName): Network;
 export declare function getMLDSASecurityLevel(level: CLIMldsaLevel): MLDSASecurityLevel;
 export declare class CLIWallet {
@@ -9,14 +10,13 @@ export declare class CLIWallet {
     private readonly network;
     private readonly mldsaLevel;
     private constructor();
+    get address(): Address;
     get p2trAddress(): string;
-    get underlyingWallet(): Wallet;
-    get keypair(): EcKeyPair;
-    get mldsaKeypair(): EcKeyPair;
+    get keypair(): Signer | ECPairInterface | null;
+    get mldsaKeypair(): QuantumBIP32Interface;
     get mldsaPublicKey(): Buffer;
     get mldsaPublicKeyHash(): string;
     get securityLevel(): CLIMldsaLevel;
-    get walletNetwork(): Network;
     static fromCredentials(credentials: CLICredentials): CLIWallet;
     static load(): CLIWallet;
     static verifyMLDSA(data: Buffer, signature: Buffer, publicKey: Buffer, level: CLIMldsaLevel): boolean;

package/build/lib/wallet.js

@@ -32,12 +32,12 @@ export class CLIWallet {
         this.network = network;
         this.mldsaLevel = mldsaLevel;
     }
+    get address() {
+        return this.wallet.address;
+    }
     get p2trAddress() {
         return this.wallet.p2tr;
     }
-    get underlyingWallet() {
-        return this.wallet;
-    }
     get keypair() {
         return this.wallet.keypair;
     }
@@ -54,9 +54,6 @@ export class CLIWallet {
     get securityLevel() {
         return this.mldsaLevel;
     }
-    get walletNetwork() {
-        return this.network;
-    }
     static fromCredentials(credentials) {
         const network = getNetwork(credentials.network);
         const securityLevel = getMLDSASecurityLevel(credentials.mldsaLevel);

package/build/types/index.d.ts

@@ -8,6 +8,7 @@ export interface CLIConfig {
     ipfsGateways: string[];
     ipfsPinningEndpoint: string;
     ipfsPinningApiKey: string;
+    ipfsPinningSecret: string;
     ipfsPinningAuthHeader: string;
     registryAddresses: Record<NetworkName, string>;
     defaultMldsaLevel: CLIMldsaLevel;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/cli",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "type": "module",
     "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
     "author": "OP_NET",
@@ -52,6 +52,7 @@
         "@inquirer/prompts": "^7.5.3",
         "bytenode": "^1.5.7",
         "commander": "^14.0.0",
+        "ecpair": "^2.1.0",
         "esbuild": "^0.25.5",
         "opnet": "^1.7.18",
         "ora": "^8.2.0"

package/src/commands/AcceptCommand.ts

@@ -6,9 +6,19 @@
 
 import { confirm } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPendingScopeTransfer, getPendingTransfer } from '../lib/registry.js';
+import {
+    getPendingScopeTransfer,
+    getPendingTransfer,
+    getRegistryContract,
+} from '../lib/registry.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 import { CLIWallet } from '../lib/wallet.js';
+import {
+    buildTransactionParams,
+    checkBalance,
+    formatSats,
+    getWalletAddress,
+} from '../lib/transaction.js';
 import { NetworkName } from '../types/index.js';
 
 interface AcceptOptions {
@@ -41,7 +51,7 @@ export class AcceptCommand extends BaseCommand {
                 this.logger.warn('Run `opnet login` to configure your wallet.');
                 process.exit(1);
             }
-            CLIWallet.fromCredentials(credentials);
+            const wallet = CLIWallet.fromCredentials(credentials);
             this.logger.success('Wallet loaded');
 
             const network = (options?.network || 'mainnet') as NetworkName;
@@ -84,12 +94,46 @@ export class AcceptCommand extends BaseCommand {
                     }
                 }
 
+                // Check wallet balance
+                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 before accepting transfer.');
+                    process.exit(1);
+                }
+                this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
                 // 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(')');
+
+                const sender = getWalletAddress(wallet);
+                const contract = getRegistryContract(network, sender);
+                const txParams = buildTransactionParams(wallet, network);
+
+                const acceptResult = await contract.acceptScopeTransfer(scopeName);
+
+                if (acceptResult.revert) {
+                    this.logger.fail('Acceptance would fail');
+                    this.logger.error(`Reason: ${acceptResult.revert}`);
+                    process.exit(1);
+                }
+
+                if (acceptResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} sats`);
+                }
+
+                const receipt = await acceptResult.sendTransaction(txParams);
+
+                this.logger.log('');
+                this.logger.success('Scope transfer accepted successfully!');
+                this.logger.log('');
+                this.logger.log(`Scope:          ${name}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+                return;
             } else {
                 const pending = await getPendingTransfer(name, network);
 
@@ -123,20 +167,49 @@ export class AcceptCommand extends BaseCommand {
                     }
                 }
 
+                // Check wallet balance
+                this.logger.info('Checking wallet balance...');
+                const { sufficient: sufficientPkg, balance: balancePkg } = await checkBalance(
+                    wallet,
+                    network,
+                );
+                if (!sufficientPkg) {
+                    this.logger.fail('Insufficient balance');
+                    this.logger.error(`Wallet balance: ${formatSats(balancePkg)}`);
+                    this.logger.error('Please fund your wallet before accepting transfer.');
+                    process.exit(1);
+                }
+                this.logger.success(`Wallet balance: ${formatSats(balancePkg)}`);
+
                 // 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)');
+                const sender = getWalletAddress(wallet);
+                const contract = getRegistryContract(network, sender);
+                const txParams = buildTransactionParams(wallet, network);
+
+                const acceptResult = await contract.acceptTransfer(name);
 
-            this.logger.log('');
-            this.logger.success('Transfer acceptance submitted!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
-            this.logger.log('');
+                if (acceptResult.revert) {
+                    this.logger.fail('Acceptance would fail');
+                    this.logger.error(`Reason: ${acceptResult.revert}`);
+                    process.exit(1);
+                }
+
+                if (acceptResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} sats`);
+                }
+
+                const receipt = await acceptResult.sendTransaction(txParams);
+
+                this.logger.log('');
+                this.logger.success('Package transfer accepted successfully!');
+                this.logger.log('');
+                this.logger.log(`Package:        ${name}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+            }
         } catch (error) {
             this.logger.fail('Acceptance failed');
             if (this.isUserCancelled(error)) {

package/src/commands/ConfigCommand.ts

@@ -8,8 +8,7 @@ import { Command } from 'commander';
 import * as os from 'os';
 import * as path from 'path';
 import { BaseCommand } from './BaseCommand.js';
-import { displayConfig, getConfigValue, saveConfig, setConfigValue } from '../lib/config.js';
-import { CLIConfig } from '../types/index.js';
+import { DEFAULT_CONFIG, displayConfig, getConfigValue, saveConfig, setConfigValue, } from '../lib/config.js';
 
 export class ConfigCommand extends BaseCommand {
     constructor() {
@@ -106,33 +105,7 @@ export class ConfigCommand extends BaseCommand {
             return;
         }
 
-        const defaultConfig: CLIConfig = {
-            defaultNetwork: 'mainnet',
-            rpcUrls: {
-                mainnet: 'https://api.opnet.org',
-                testnet: 'https://testnet.opnet.org',
-                regtest: 'http://localhost:9001',
-            },
-            ipfsGateway: 'https://ipfs.opnet.org/ipfs/',
-            ipfsGateways: [
-                'https://ipfs.opnet.org/ipfs/',
-                'https://ipfs.io/ipfs/',
-                'https://cloudflare-ipfs.com/ipfs/',
-                'https://dweb.link/ipfs/',
-            ],
-            ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
-            ipfsPinningApiKey: '',
-            ipfsPinningAuthHeader: 'Authorization',
-            registryAddresses: {
-                mainnet: '',
-                testnet: '',
-                regtest: '',
-            },
-            defaultMldsaLevel: 44,
-            indexerUrl: 'https://indexer.opnet.org',
-        };
-
-        saveConfig(defaultConfig);
+        saveConfig(DEFAULT_CONFIG);
         this.logger.success('Configuration reset to defaults.');
     }
 

package/src/commands/DeprecateCommand.ts

@@ -6,9 +6,15 @@
 
 import { confirm, input } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getVersion, isVersionImmutable } from '../lib/registry.js';
+import { getPackage, getRegistryContract, getVersion, isVersionImmutable } from '../lib/registry.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 import { CLIWallet } from '../lib/wallet.js';
+import {
+    buildTransactionParams,
+    checkBalance,
+    formatSats,
+    getWalletAddress,
+} from '../lib/transaction.js';
 import { NetworkName } from '../types/index.js';
 
 interface DeprecateOptions {
@@ -48,7 +54,7 @@ export class DeprecateCommand extends BaseCommand {
                 this.logger.warn('Run `opnet login` to configure your wallet.');
                 process.exit(1);
             }
-            CLIWallet.fromCredentials(credentials);
+            const wallet = CLIWallet.fromCredentials(credentials);
             this.logger.success('Wallet loaded');
 
             // Get package info
@@ -128,19 +134,50 @@ export class DeprecateCommand extends BaseCommand {
                 }
             }
 
+            // Check wallet balance
+            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 before deprecating.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+
             // Execute deprecation
             this.logger.info('Deprecating version...');
-            this.logger.warn('Deprecation transaction required.');
-            this.logger.log('Transaction would call: deprecateVersion(');
-            this.logger.log(`  packageName: "${packageName}",`);
-            this.logger.log(`  version: "${targetVersion}",`);
-            this.logger.log(`  reason: "${message}"`);
-            this.logger.log(')');
-            this.logger.info('Deprecation (transaction pending)');
 
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+
+            const deprecateResult = await contract.deprecateVersion(
+                packageName,
+                targetVersion,
+                message,
+            );
+
+            if (deprecateResult.revert) {
+                this.logger.fail('Deprecation would fail');
+                this.logger.error(`Reason: ${deprecateResult.revert}`);
+                process.exit(1);
+            }
+
+            if (deprecateResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${deprecateResult.estimatedGas} sats`);
+            }
+
+            const receipt = await deprecateResult.sendTransaction(txParams);
+
+            this.logger.log('');
+            this.logger.success('Version deprecated successfully!');
             this.logger.log('');
-            this.logger.success('Deprecation submitted!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log(`Package:        ${packageName}`);
+            this.logger.log(`Version:        ${targetVersion}`);
+            this.logger.log(`Reason:         ${message}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
             this.logger.log('');
         } catch (error) {
             this.logger.fail('Deprecation failed');

package/src/commands/InitCommand.ts

@@ -223,12 +223,6 @@ export class InitCommand extends BaseCommand {
                     configDir: false,
                     tempDir: false,
                 },
-                blockchain: {
-                    blocks: false,
-                    transactions: false,
-                    contracts: false,
-                    utxos: false,
-                },
             },
             resources: {
                 memory: {