@btc-vision/cli 1.0.2 → 1.0.4

package/build/commands/ScopeRegisterCommand.js

@@ -0,0 +1,115 @@
+import { confirm } from '@inquirer/prompts';
+import { BaseCommand } from './BaseCommand.js';
+import { getRegistryContract, getScope, getScopePrice } 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';
+export class ScopeRegisterCommand extends BaseCommand {
+    constructor() {
+        super('scope:register', 'Register a new scope in the registry');
+    }
+    configure() {
+        this.command
+            .argument('<name>', 'Scope name (without @)')
+            .option('-n, --network <network>', 'Network', 'mainnet')
+            .option('-y, --yes', 'Skip confirmation')
+            .action((name, options) => this.execute(name, options || { network: 'mainnet' }));
+    }
+    async execute(name, options) {
+        try {
+            const scopeName = name.startsWith('@') ? name.substring(1) : name;
+            if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(scopeName) && !/^[a-z]$/.test(scopeName)) {
+                this.logger.fail('Invalid scope name');
+                this.logger.error('Scope name must:');
+                this.logger.error('  - Start with a lowercase letter');
+                this.logger.error('  - Contain only lowercase letters, numbers, and hyphens');
+                this.logger.error('  - End with a letter or number');
+                process.exit(1);
+            }
+            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);
+            }
+            const wallet = CLIWallet.fromCredentials(credentials);
+            this.logger.success('Wallet loaded');
+            const network = (options?.network || 'mainnet');
+            this.logger.info(`Checking if @${scopeName} is available...`);
+            const existingScope = await getScope(scopeName, network);
+            if (existingScope) {
+                this.logger.fail('Scope already registered');
+                this.logger.error(`Scope @${scopeName} is already registered.`);
+                this.logger.log(`Owner: ${existingScope.owner}`);
+                process.exit(1);
+            }
+            this.logger.success(`Scope @${scopeName} is available`);
+            this.logger.info('Fetching registration price...');
+            const scopePrice = await getScopePrice(network);
+            this.logger.success(`Registration price: ${formatSats(scopePrice)}`);
+            this.logger.info('Checking wallet balance...');
+            const minRequired = scopePrice + 50000n;
+            const { sufficient, balance } = await checkBalance(wallet, network, minRequired);
+            if (!sufficient) {
+                this.logger.fail('Insufficient balance');
+                this.logger.error(`Wallet balance: ${formatSats(balance)}`);
+                this.logger.error(`Required (approx): ${formatSats(minRequired)}`);
+                this.logger.error('Please fund your wallet before registering a scope.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
+            this.logger.log('');
+            this.logger.info('Scope Registration Summary');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Scope:    @${scopeName}`);
+            this.logger.log(`Price:    ${formatSats(scopePrice)}`);
+            this.logger.log(`Network:  ${options?.network}`);
+            this.logger.log(`Address:  ${wallet.p2trAddress}`);
+            this.logger.log('');
+            if (!options?.yes) {
+                const confirmed = await confirm({
+                    message: `Register scope @${scopeName}?`,
+                    default: true,
+                });
+                if (!confirmed) {
+                    this.logger.warn('Registration cancelled.');
+                    return;
+                }
+            }
+            this.logger.info('Registering scope...');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const registerResult = await contract.registerScope(scopeName);
+            if (registerResult.revert) {
+                this.logger.fail('Registration would fail');
+                this.logger.error(`Reason: ${registerResult.revert}`);
+                process.exit(1);
+            }
+            if (registerResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+            }
+            const receipt = await registerResult.sendTransaction(txParams);
+            this.logger.log('');
+            this.logger.success('Scope registered successfully!');
+            this.logger.log('');
+            this.logger.log(`Scope:          @${scopeName}`);
+            this.logger.log(`Owner:          ${wallet.p2trAddress}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+            this.logger.log('');
+            this.logger.info('You can now publish packages under this scope using: opnet publish');
+            this.logger.log('');
+        }
+        catch (error) {
+            this.logger.fail('Scope registration failed');
+            if (this.isUserCancelled(error)) {
+                this.logger.warn('Registration cancelled.');
+                process.exit(0);
+            }
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const scopeRegisterCommand = new ScopeRegisterCommand().getCommand();

package/build/commands/SearchCommand.js

@@ -79,8 +79,7 @@ export class SearchCommand extends BaseCommand {
                 this.logger.info(`  OPNet Range:   ${latestVersionInfo.opnetVersionRange}`);
                 this.logger.info(`  IPFS CID:      ${latestVersionInfo.ipfsCid}`);
                 this.logger.info(`  Deprecated:    ${latestVersionInfo.deprecated ? 'Yes' : 'No'}`);
-                const publishDate = new Date(Number(latestVersionInfo.publishedAt) * 1000);
-                this.logger.info(`  Published:     ${publishDate.toISOString().split('T')[0]}`);
+                this.logger.info(`  Published at:  Block ${latestVersionInfo.publishedAt}`);
             }
             this.logger.log('');
             this.logger.info('Install with:');

package/build/commands/TransferCommand.js

@@ -1,8 +1,10 @@
 import { confirm, input } from '@inquirer/prompts';
+import { Address } from '@btc-vision/transaction';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getPendingScopeTransfer, getPendingTransfer, getScope, } from '../lib/registry.js';
+import { getPackage, getPendingScopeTransfer, getPendingTransfer, getRegistryContract, getScope, } 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';
 export class TransferCommand extends BaseCommand {
     constructor() {
         super('transfer', 'Initiate ownership transfer of a package or scope');
@@ -25,7 +27,7 @@ export class TransferCommand 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');
             const isScope = name.startsWith('@') && !name.includes('/');
@@ -86,26 +88,63 @@ export class TransferCommand extends BaseCommand {
                     return;
                 }
             }
+            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 initiating transfer.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
             this.logger.info('Initiating transfer...');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const newOwnerAddress = Address.fromString(targetOwner);
             if (isScope) {
                 const scopeName = name.substring(1);
-                this.logger.warn('Transfer transaction required.');
-                this.logger.log('Transaction would call: initiateScopeTransfer(');
-                this.logger.log(`  scopeName: "${scopeName}",`);
-                this.logger.log(`  newOwner: "${targetOwner}"`);
-                this.logger.log(')');
+                const transferResult = await contract.initiateScopeTransfer(scopeName, newOwnerAddress);
+                if (transferResult.revert) {
+                    this.logger.fail('Transfer initiation would fail');
+                    this.logger.error(`Reason: ${transferResult.revert}`);
+                    process.exit(1);
+                }
+                if (transferResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                }
+                const receipt = await transferResult.sendTransaction(txParams);
+                this.logger.log('');
+                this.logger.success('Scope transfer initiated successfully!');
+                this.logger.log('');
+                this.logger.log(`Scope:          ${name}`);
+                this.logger.log(`New Owner:      ${targetOwner}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+                this.logger.warn('Note: The new owner must call `opnet accept` to complete the transfer.');
             }
             else {
-                this.logger.warn('Transfer transaction required.');
-                this.logger.log('Transaction would call: initiateTransfer(');
-                this.logger.log(`  packageName: "${name}",`);
-                this.logger.log(`  newOwner: "${targetOwner}"`);
-                this.logger.log(')');
+                const transferResult = await contract.initiateTransfer(name, newOwnerAddress);
+                if (transferResult.revert) {
+                    this.logger.fail('Transfer initiation would fail');
+                    this.logger.error(`Reason: ${transferResult.revert}`);
+                    process.exit(1);
+                }
+                if (transferResult.estimatedGas) {
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                }
+                const receipt = await transferResult.sendTransaction(txParams);
+                this.logger.log('');
+                this.logger.success('Package transfer initiated successfully!');
+                this.logger.log('');
+                this.logger.log(`Package:        ${name}`);
+                this.logger.log(`New Owner:      ${targetOwner}`);
+                this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+                this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
+                this.logger.log('');
+                this.logger.warn('Note: The new owner must call `opnet accept` to complete the transfer.');
             }
-            this.logger.info('Transfer (transaction pending)');
-            this.logger.log('');
-            this.logger.success('Transfer initiated!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
             this.logger.log('');
         }
         catch (error) {
@@ -119,6 +158,13 @@ export class TransferCommand extends BaseCommand {
     }
     async handleCancel(name, isScope, network, options) {
         this.logger.info('Checking pending transfer...');
+        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);
+        }
+        const wallet = CLIWallet.fromCredentials(credentials);
         if (isScope) {
             const scopeName = name.substring(1);
             const pending = await getPendingScopeTransfer(scopeName, network);
@@ -138,12 +184,35 @@ export class TransferCommand extends BaseCommand {
                     return;
                 }
             }
+            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)}`);
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
             this.logger.info('Cancelling transfer...');
-            this.logger.warn('Cancellation transaction required.');
-            this.logger.log('Transaction would call: cancelScopeTransfer(');
-            this.logger.log(`  scopeName: "${scopeName}"`);
-            this.logger.log(')');
-            this.logger.info('Cancellation (transaction pending)');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const cancelResult = await contract.cancelScopeTransfer(scopeName);
+            if (cancelResult.revert) {
+                this.logger.fail('Cancellation would fail');
+                this.logger.error(`Reason: ${cancelResult.revert}`);
+                process.exit(1);
+            }
+            if (cancelResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+            }
+            const receipt = await cancelResult.sendTransaction(txParams);
+            this.logger.log('');
+            this.logger.success('Scope transfer cancelled 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('');
         }
         else {
             const pending = await getPendingTransfer(name, network);
@@ -163,17 +232,36 @@ export class TransferCommand extends BaseCommand {
                     return;
                 }
             }
+            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)}`);
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
             this.logger.info('Cancelling transfer...');
-            this.logger.warn('Cancellation transaction required.');
-            this.logger.log('Transaction would call: cancelTransfer(');
-            this.logger.log(`  packageName: "${name}"`);
-            this.logger.log(')');
-            this.logger.info('Cancellation (transaction pending)');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const cancelResult = await contract.cancelTransfer(name);
+            if (cancelResult.revert) {
+                this.logger.fail('Cancellation would fail');
+                this.logger.error(`Reason: ${cancelResult.revert}`);
+                process.exit(1);
+            }
+            if (cancelResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+            }
+            const receipt = await cancelResult.sendTransaction(txParams);
+            this.logger.log('');
+            this.logger.success('Package transfer cancelled 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('');
         }
-        this.logger.log('');
-        this.logger.success('Transfer cancellation submitted!');
-        this.logger.warn('Note: Registry transaction support is coming soon.');
-        this.logger.log('');
     }
 }
 export const transferCommand = new TransferCommand().getCommand();

package/build/commands/UndeprecateCommand.js

@@ -1,8 +1,9 @@
 import { confirm } 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';
 export class UndeprecateCommand extends BaseCommand {
     constructor() {
         super('undeprecate', 'Remove deprecation from a package version');
@@ -24,7 +25,7 @@ export class UndeprecateCommand 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');
             this.logger.info('Fetching package info...');
             const network = (options?.network || 'mainnet');
@@ -70,16 +71,36 @@ export class UndeprecateCommand extends BaseCommand {
                     return;
                 }
             }
+            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 undeprecating.');
+                process.exit(1);
+            }
+            this.logger.success(`Wallet balance: ${formatSats(balance)}`);
             this.logger.info('Removing deprecation...');
-            this.logger.warn('Undeprecation transaction required.');
-            this.logger.log('Transaction would call: undeprecateVersion(');
-            this.logger.log(`  packageName: "${packageName}",`);
-            this.logger.log(`  version: "${version}"`);
-            this.logger.log(')');
-            this.logger.info('Undeprecation (transaction pending)');
+            const sender = getWalletAddress(wallet);
+            const contract = getRegistryContract(network, sender);
+            const txParams = buildTransactionParams(wallet, network);
+            const undeprecateResult = await contract.undeprecateVersion(packageName, version);
+            if (undeprecateResult.revert) {
+                this.logger.fail('Undeprecation would fail');
+                this.logger.error(`Reason: ${undeprecateResult.revert}`);
+                process.exit(1);
+            }
+            if (undeprecateResult.estimatedGas) {
+                this.logger.info(`Estimated gas: ${undeprecateResult.estimatedGas} sats`);
+            }
+            const receipt = await undeprecateResult.sendTransaction(txParams);
+            this.logger.log('');
+            this.logger.success('Deprecation removed successfully!');
             this.logger.log('');
-            this.logger.success('Undeprecation submitted!');
-            this.logger.warn('Note: Registry transaction support is coming soon.');
+            this.logger.log(`Package:        ${packageName}`);
+            this.logger.log(`Version:        ${version}`);
+            this.logger.log(`Transaction ID: ${receipt.transactionId}`);
+            this.logger.log(`Fees paid:      ${formatSats(receipt.estimatedFees)}`);
             this.logger.log('');
         }
         catch (error) {

package/build/index.js

@@ -16,6 +16,7 @@ import { deprecateCommand } from './commands/DeprecateCommand.js';
 import { undeprecateCommand } from './commands/UndeprecateCommand.js';
 import { transferCommand } from './commands/TransferCommand.js';
 import { acceptCommand } from './commands/AcceptCommand.js';
+import { scopeRegisterCommand } from './commands/ScopeRegisterCommand.js';
 import { installCommand } from './commands/InstallCommand.js';
 import { updateCommand } from './commands/UpdateCommand.js';
 import { listCommand } from './commands/ListCommand.js';
@@ -41,6 +42,7 @@ program.addCommand(deprecateCommand);
 program.addCommand(undeprecateCommand);
 program.addCommand(transferCommand);
 program.addCommand(acceptCommand);
+program.addCommand(scopeRegisterCommand);
 program.addCommand(installCommand);
 program.addCommand(updateCommand);
 program.addCommand(listCommand);

package/build/lib/config.d.ts

@@ -1,4 +1,5 @@
 import { CLIConfig, CLIMldsaLevel, NetworkName } from '../types/index.js';
+export declare const DEFAULT_CONFIG: CLIConfig;
 export declare function ensureConfigDir(): void;
 export declare function loadConfig(): CLIConfig;
 export declare function saveConfig(config: CLIConfig): void;

package/build/lib/config.js

@@ -3,7 +3,7 @@ import * as path from 'path';
 import * as os from 'os';
 const CONFIG_DIR = path.join(os.homedir(), '.opnet');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const DEFAULT_CONFIG = {
+export const DEFAULT_CONFIG = {
     defaultNetwork: 'regtest',
     rpcUrls: {
         mainnet: 'https://api.opnet.org',
@@ -19,11 +19,12 @@ const DEFAULT_CONFIG = {
     ],
     ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
     ipfsPinningApiKey: '',
+    ipfsPinningSecret: '',
     ipfsPinningAuthHeader: 'Authorization',
     registryAddresses: {
         mainnet: '',
         testnet: '',
-        regtest: '',
+        regtest: '0x0737d17d0eff9915208f3c20ed7659587889bc94d25972672b3a6c03ff4ddbcc',
     },
     defaultMldsaLevel: 44,
     indexerUrl: 'https://indexer.opnet.org',

package/build/lib/ipfs.js

@@ -42,86 +42,95 @@ async function httpRequest(url, options) {
     });
 }
 export async function pinToIPFS(data, name) {
-    const config = loadConfig();
-    const endpoint = config.ipfsPinningEndpoint;
-    if (!endpoint) {
-        throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
-    }
-    const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
-    const fileName = name || 'plugin.opnet';
-    const formParts = [];
-    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'));
-    formParts.push(Buffer.from(`--${boundary}--\r\n`));
-    const body = Buffer.concat(formParts);
-    const headers = {
-        'Content-Type': `multipart/form-data; boundary=${boundary}`,
-        'Content-Length': body.length.toString(),
-    };
-    if (config.ipfsPinningAuthHeader) {
-        const [headerName, headerValue] = config.ipfsPinningAuthHeader
-            .split(':')
-            .map((s) => s.trim());
-        if (headerName && headerValue) {
-            headers[headerName] = headerValue;
+    try {
+        const config = loadConfig();
+        const endpoint = config.ipfsPinningEndpoint;
+        if (!endpoint) {
+            throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
         }
-    }
-    else if (config.ipfsPinningApiKey) {
-        headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
-    }
-    const url = new URL(endpoint);
-    let requestUrl;
-    if (url.hostname.includes('ipfs.opnet.org')) {
-        requestUrl = endpoint;
-    }
-    else if (url.hostname.includes('pinata')) {
-        requestUrl = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
-        if (config.ipfsPinningApiKey) {
-            headers['pinata_api_key'] = config.ipfsPinningApiKey;
+        const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
+        const fileName = name || 'plugin.opnet';
+        const formParts = [];
+        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'));
+        formParts.push(Buffer.from(`--${boundary}--\r\n`));
+        const body = Buffer.concat(formParts);
+        const headers = {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': body.length.toString(),
+        };
+        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}`;
+        }
+        const url = new URL(endpoint);
+        let requestUrl;
+        if (url.hostname.includes('ipfs.opnet.org')) {
+            requestUrl = endpoint;
+        }
+        else if (url.hostname.includes('pinata')) {
+            requestUrl = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
+            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')) {
+            requestUrl = endpoint.endsWith('/') ? endpoint + 'upload' : endpoint + '/upload';
+        }
+        else if (url.hostname.includes('nft.storage')) {
+            requestUrl = 'https://api.nft.storage/upload';
+        }
+        else if (url.pathname.includes('/api/v0/')) {
+            requestUrl = endpoint;
+        }
+        else {
+            requestUrl = endpoint.endsWith('/') ? endpoint + 'pins' : endpoint + '/pins';
+        }
+        const response = await httpRequest(requestUrl, {
+            method: 'POST',
+            headers,
+            body,
+            timeout: 120000,
+        });
+        const result = JSON.parse(response.toString());
+        let cid;
+        if (typeof result.IpfsHash === 'string') {
+            cid = result.IpfsHash;
+        }
+        else if (typeof result.cid === 'string') {
+            cid = result.cid;
+        }
+        else if (typeof result.Hash === 'string') {
+            cid = result.Hash;
+        }
+        else if (result.value &&
+            typeof result.value.cid === 'string') {
+            cid = result.value.cid;
+        }
+        if (!cid) {
+            throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
+        }
+        return {
+            cid,
+            size: data.length,
+        };
     }
-    else if (url.hostname.includes('web3.storage') || url.hostname.includes('w3s.link')) {
-        requestUrl = endpoint.endsWith('/') ? endpoint + 'upload' : endpoint + '/upload';
-    }
-    else if (url.hostname.includes('nft.storage')) {
-        requestUrl = 'https://api.nft.storage/upload';
-    }
-    else if (url.pathname.includes('/api/v0/')) {
-        requestUrl = endpoint;
-    }
-    else {
-        requestUrl = endpoint.endsWith('/') ? endpoint + 'pins' : endpoint + '/pins';
-    }
-    const response = await httpRequest(requestUrl, {
-        method: 'POST',
-        headers,
-        body,
-        timeout: 120000,
-    });
-    const result = JSON.parse(response.toString());
-    let cid;
-    if (typeof result.IpfsHash === 'string') {
-        cid = result.IpfsHash;
-    }
-    else if (typeof result.cid === 'string') {
-        cid = result.cid;
-    }
-    else if (typeof result.Hash === 'string') {
-        cid = result.Hash;
-    }
-    else if (result.value && typeof result.value.cid === 'string') {
-        cid = result.value.cid;
-    }
-    if (!cid) {
-        throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
+    catch (e) {
+        throw new Error(`IPFS pinning failed: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return {
-        cid,
-        size: data.length,
-    };
 }
 export async function fetchFromIPFS(cid) {
     const config = loadConfig();

package/build/lib/registry.d.ts

@@ -32,7 +32,7 @@ export interface PendingTransferInfo {
     pendingOwner: Address;
     initiatedAt: bigint;
 }
-export declare function getRegistryContract(network?: NetworkName): IPackageRegistry;
+export declare function getRegistryContract(network?: NetworkName, sender?: Address): 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>;

package/build/lib/registry.js

@@ -5,10 +5,10 @@ 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) {
+export function getRegistryContract(network, sender) {
     const config = loadConfig();
     const targetNetwork = network || config.defaultNetwork;
-    const cacheKey = targetNetwork;
+    const cacheKey = sender ? `${targetNetwork}:${sender.toHex()}` : targetNetwork;
     const cached = registryCache.get(cacheKey);
     if (cached) {
         return cached;
@@ -16,7 +16,7 @@ export function getRegistryContract(network) {
     const provider = getProvider(targetNetwork);
     const registryAddress = getRegistryContractAddress(targetNetwork);
     const bitcoinNetwork = getNetwork(targetNetwork);
-    const contract = getContract(registryAddress, PACKAGE_REGISTRY_ABI, provider, bitcoinNetwork);
+    const contract = getContract(registryAddress, PACKAGE_REGISTRY_ABI, provider, bitcoinNetwork, sender);
     registryCache.set(cacheKey, contract);
     return contract;
 }