@btc-vision/cli 1.0.1 → 1.0.3

package/src/lib/ipfs.ts

@@ -103,117 +103,131 @@ async function httpRequest(url: string, options: RequestOptions): Promise<Buffer
  * @returns The IPFS CID
  */
 export async function pinToIPFS(data: Buffer, name?: string): Promise<PinResult> {
-    const config = loadConfig();
-    const endpoint = config.ipfsPinningEndpoint;
+    try {
+        const config = loadConfig();
+        const endpoint = config.ipfsPinningEndpoint;
+
+        if (!endpoint) {
+            throw new Error(
+                'IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`',
+            );
+        }
+
+        // Build multipart form data
+        const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
+        const fileName = name || 'plugin.opnet';
+
+        const formParts: Buffer[] = [];
 
-    if (!endpoint) {
-        throw new Error(
-            'IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`',
+        // File part
+        formParts.push(
+            Buffer.from(
+                `--${boundary}\r\n` +
+                    `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n` +
+                    `Content-Type: application/octet-stream\r\n\r\n`,
+            ),
         );
-    }
+        formParts.push(data);
+        formParts.push(Buffer.from('\r\n'));
 
-    // Build multipart form data
-    const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
-    const fileName = name || 'plugin.opnet';
+        // End boundary
+        formParts.push(Buffer.from(`--${boundary}--\r\n`));
 
-    const formParts: Buffer[] = [];
+        const body = Buffer.concat(formParts);
 
-    // File part
-    formParts.push(
-        Buffer.from(
-            `--${boundary}\r\n` +
-                `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n` +
-                `Content-Type: application/octet-stream\r\n\r\n`,
-        ),
-    );
-    formParts.push(data);
-    formParts.push(Buffer.from('\r\n'));
-
-    // End boundary
-    formParts.push(Buffer.from(`--${boundary}--\r\n`));
-
-    const body = Buffer.concat(formParts);
-
-    // Build headers
-    const headers: Record<string, string> = {
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        'Content-Length': body.length.toString(),
-    };
-
-    // Add authorization if configured
-    if (config.ipfsPinningAuthHeader) {
-        const [headerName, headerValue] = config.ipfsPinningAuthHeader
-            .split(':')
-            .map((s) => s.trim());
-        if (headerName && headerValue) {
-            headers[headerName] = headerValue;
+        // Build headers
+        const headers: Record<string, string> = {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': body.length.toString(),
+        };
+
+        // Add authorization if configured
+        if (config.ipfsPinningAuthHeader) {
+            const [headerName, headerValue] = config.ipfsPinningAuthHeader
+                .split(':')
+                .map((s) => s.trim());
+            if (headerName && headerValue) {
+                headers[headerName] = headerValue;
+            }
+        } else if (config.ipfsPinningApiKey) {
+            headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
         }
-    } else if (config.ipfsPinningApiKey) {
-        headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
-    }
 
-    // Detect pinning service type from URL and adjust request
-    const url = new URL(endpoint);
-
-    let requestUrl: string;
-    if (url.hostname.includes('ipfs.opnet.org')) {
-        // OPNet IPFS gateway - uses standard IPFS API
-        requestUrl = endpoint;
-    } else if (url.hostname.includes('pinata')) {
-        // Pinata-specific endpoint
-        requestUrl = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
-        if (config.ipfsPinningApiKey) {
-            headers['pinata_api_key'] = config.ipfsPinningApiKey;
+        // Detect pinning service type from URL and adjust request
+        const url = new URL(endpoint);
+
+        let requestUrl: string;
+        if (url.hostname.includes('ipfs.opnet.org')) {
+            // OPNet IPFS gateway - uses standard IPFS API
+            requestUrl = endpoint;
+        } else if (url.hostname.includes('pinata')) {
+            // Pinata-specific endpoint
+            requestUrl = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
+            // Only set pinata_api_key header if using API key (not JWT)
+            // JWT tokens start with "eyJ", API keys don't
+            if (config.ipfsPinningApiKey && !config.ipfsPinningApiKey.startsWith('eyJ')) {
+                headers['pinata_api_key'] = config.ipfsPinningApiKey;
+                if (config.ipfsPinningSecret) {
+                    headers['pinata_secret_api_key'] = config.ipfsPinningSecret;
+                }
+            }
+        } else if (url.hostname.includes('web3.storage') || url.hostname.includes('w3s.link')) {
+            // web3.storage endpoint
+            requestUrl = endpoint.endsWith('/') ? endpoint + 'upload' : endpoint + '/upload';
+        } else if (url.hostname.includes('nft.storage')) {
+            // nft.storage endpoint
+            requestUrl = 'https://api.nft.storage/upload';
+        } else if (url.pathname.includes('/api/v0/')) {
+            // Standard IPFS API endpoint
+            requestUrl = endpoint;
+        } else {
+            // Generic IPFS pinning service (assumed to follow IPFS Pinning Services API)
+            requestUrl = endpoint.endsWith('/') ? endpoint + 'pins' : endpoint + '/pins';
         }
-    } else if (url.hostname.includes('web3.storage') || url.hostname.includes('w3s.link')) {
-        // web3.storage endpoint
-        requestUrl = endpoint.endsWith('/') ? endpoint + 'upload' : endpoint + '/upload';
-    } else if (url.hostname.includes('nft.storage')) {
-        // nft.storage endpoint
-        requestUrl = 'https://api.nft.storage/upload';
-    } else if (url.pathname.includes('/api/v0/')) {
-        // Standard IPFS API endpoint
-        requestUrl = endpoint;
-    } else {
-        // Generic IPFS pinning service (assumed to follow IPFS Pinning Services API)
-        requestUrl = endpoint.endsWith('/') ? endpoint + 'pins' : endpoint + '/pins';
-    }
 
-    const response = await httpRequest(requestUrl, {
-        method: 'POST',
-        headers,
-        body,
-        timeout: 120000, // 2 minutes for upload
-    });
+        const response = await httpRequest(requestUrl, {
+            method: 'POST',
+            headers,
+            body,
+            timeout: 120000, // 2 minutes for upload
+        });
 
-    // Parse response to extract CID
-    const result = JSON.parse(response.toString()) as Record<string, unknown>;
-
-    // Handle different response formats
-    let cid: string | undefined;
-
-    if (typeof result.IpfsHash === 'string') {
-        // Pinata format
-        cid = result.IpfsHash;
-    } else if (typeof result.cid === 'string') {
-        // web3.storage / nft.storage format
-        cid = result.cid;
-    } else if (typeof result.Hash === 'string') {
-        // IPFS API format
-        cid = result.Hash;
-    } else if (result.value && typeof (result.value as Record<string, unknown>).cid === 'string') {
-        // NFT.storage wrapped format
-        cid = (result.value as Record<string, unknown>).cid as string;
-    }
+        // Parse response to extract CID
+        const result = JSON.parse(response.toString()) as Record<string, unknown>;
+
+        // Handle different response formats
+        let cid: string | undefined;
+
+        if (typeof result.IpfsHash === 'string') {
+            // Pinata format
+            cid = result.IpfsHash;
+        } else if (typeof result.cid === 'string') {
+            // web3.storage / nft.storage format
+            cid = result.cid;
+        } else if (typeof result.Hash === 'string') {
+            // IPFS API format
+            cid = result.Hash;
+        } else if (
+            result.value &&
+            typeof (result.value as Record<string, unknown>).cid === 'string'
+        ) {
+            // NFT.storage wrapped format
+            cid = (result.value as Record<string, unknown>).cid as string;
+        }
 
-    if (!cid) {
-        throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
-    }
+        if (!cid) {
+            throw new Error(
+                `Failed to extract CID from pinning response: ${JSON.stringify(result)}`,
+            );
+        }
 
-    return {
-        cid,
-        size: data.length,
-    };
+        return {
+            cid,
+            size: data.length,
+        };
+    } catch (e) {
+        throw new Error(`IPFS pinning failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
 }
 
 /**

package/src/lib/manifest.ts

@@ -167,7 +167,7 @@ export function createManifest(options: {
     return {
         name: options.name,
         version: '1.0.0',
-        opnetVersion: '^1.0.0',
+        opnetVersion: '>=0.0.1',
         main: 'dist/index.jsc',
         target: 'bytenode',
         type: 'plugin',

package/src/lib/registry.ts

@@ -73,12 +73,14 @@ 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): IPackageRegistry {
+export function getRegistryContract(network?: NetworkName, sender?: Address): IPackageRegistry {
     const config = loadConfig();
     const targetNetwork = network || config.defaultNetwork;
-    const cacheKey = targetNetwork;
+    // 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) {
@@ -94,6 +96,7 @@ export function getRegistryContract(network?: NetworkName): IPackageRegistry {
         PACKAGE_REGISTRY_ABI,
         provider,
         bitcoinNetwork,
+        sender,
     );
 
     registryCache.set(cacheKey, contract);

package/src/lib/transaction.ts

@@ -0,0 +1,205 @@
+/**
+ * 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));
+}

package/src/lib/wallet.ts

@@ -6,12 +6,13 @@
  * @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 { Network, networks, Signer } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel, QuantumBIP32Factory, QuantumBIP32Interface } from '@btc-vision/bip32';
+import { Address, 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';
+import { ECPairInterface } from 'ecpair';
 
 /**
  * Convert CLI network name to bitcoin-js Network object
@@ -55,6 +56,10 @@ export class CLIWallet {
         this.mldsaLevel = mldsaLevel;
     }
 
+    get address(): Address {
+        return this.wallet.address;
+    }
+
     /**
      * Get the P2TR (taproot) address
      */
@@ -62,24 +67,17 @@ export class CLIWallet {
         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 {
+    get keypair(): Signer | ECPairInterface | null {
         return this.wallet.keypair;
     }
 
     /**
      * Get the MLDSA keypair for quantum-resistant signing
      */
-    get mldsaKeypair(): EcKeyPair {
+    get mldsaKeypair(): QuantumBIP32Interface {
         return this.wallet.mldsaKeypair;
     }
 
@@ -105,13 +103,6 @@ export class CLIWallet {
         return this.mldsaLevel;
     }
 
-    /**
-     * Get the network this wallet is configured for
-     */
-    get walletNetwork(): Network {
-        return this.network;
-    }
-
     /**
      * Create a wallet from credentials
      *

package/src/types/index.ts

@@ -32,8 +32,10 @@ export interface CLIConfig {
     ipfsGateways: string[];
     /** IPFS pinning service endpoint */
     ipfsPinningEndpoint: string;
-    /** IPFS pinning API key */
+    /** IPFS pinning API key (or JWT token) */
     ipfsPinningApiKey: string;
+    /** IPFS pinning API secret (for services requiring key+secret) */
+    ipfsPinningSecret: string;
     /** Authorization header name for pinning service */
     ipfsPinningAuthHeader: string;
     /** Registry contract addresses per network */