@btc-vision/cli 1.0.1 → 1.0.3

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/SignCommand.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { BaseCommand } from './BaseCommand.js';
-import { buildOpnetBinary, computeChecksum, formatFileSize, parseOpnetBinary, } from '../lib/binary.js';
+import { buildOpnetBinary, formatFileSize, parseOpnetBinary } from '../lib/binary.js';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 export class SignCommand extends BaseCommand {
@@ -48,20 +48,17 @@ export class SignCommand extends BaseCommand {
                 this.logger.log('Use --force to re-sign with your key.');
                 process.exit(1);
             }
-            this.logger.info('Signing...');
-            const metadataBytes = Buffer.from(parsed.rawMetadata, 'utf-8');
-            const checksum = computeChecksum(metadataBytes, parsed.bytecode, parsed.proto ?? Buffer.alloc(0));
-            const signature = wallet.signMLDSA(checksum);
-            this.logger.success(`Signed (${formatFileSize(signature.length)} signature)`);
-            this.logger.info('Rebuilding binary...');
-            const newBinary = buildOpnetBinary({
+            this.logger.info('Signing and rebuilding binary...');
+            const signFn = (checksum) => wallet.signMLDSA(checksum);
+            const { binary: newBinary, checksum } = buildOpnetBinary({
                 mldsaLevel: wallet.securityLevel,
                 publicKey: wallet.mldsaPublicKey,
-                signature,
                 metadata: parsed.metadata,
                 bytecode: parsed.bytecode,
                 proto: parsed.proto ?? Buffer.alloc(0),
+                signFn,
             });
+            this.logger.success(`Signed (checksum: sha256:${checksum.toString('hex').substring(0, 16)}...)`);
             this.logger.success(`Binary rebuilt (${formatFileSize(newBinary.length)})`);
             const outputPath = options.output || file;
             fs.writeFileSync(outputPath, newBinary);

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/binary.d.ts

@@ -6,11 +6,14 @@ export declare function verifyChecksum(parsed: IParsedPluginFile): boolean;
 export declare function buildOpnetBinary(options: {
     mldsaLevel: CLIMldsaLevel;
     publicKey: Buffer;
-    signature: Buffer;
     metadata: IPluginMetadata;
     bytecode: Buffer;
     proto?: Buffer;
-}): Buffer;
+    signFn?: (checksum: Buffer) => Buffer;
+}): {
+    binary: Buffer;
+    checksum: Buffer;
+};
 export declare function extractMetadata(data: Buffer): IPluginMetadata | null;
 export declare function getParsedMldsaLevel(parsed: IParsedPluginFile): CLIMldsaLevel;
 export declare function formatFileSize(bytes: number): string;

package/build/lib/binary.js

@@ -91,19 +91,24 @@ export function verifyChecksum(parsed) {
     return computed.equals(parsed.checksum);
 }
 export function buildOpnetBinary(options) {
-    const { mldsaLevel, publicKey, signature, metadata, bytecode, proto = Buffer.alloc(0), } = options;
+    const { mldsaLevel, publicKey, metadata, bytecode, proto = Buffer.alloc(0), signFn } = options;
     const sdkLevel = cliLevelToMLDSALevel(mldsaLevel);
     const expectedPkSize = MLDSA_PUBLIC_KEY_SIZES[sdkLevel];
     const expectedSigSize = MLDSA_SIGNATURE_SIZES[sdkLevel];
     if (publicKey.length !== expectedPkSize) {
         throw new Error(`Public key size mismatch: expected ${expectedPkSize}, got ${publicKey.length}`);
     }
+    const tempMetadata = { ...metadata, checksum: '' };
+    const tempMetadataBytes = Buffer.from(JSON.stringify(tempMetadata), 'utf-8');
+    const checksum = computeChecksum(tempMetadataBytes, bytecode, proto);
+    const checksumHex = `sha256:${checksum.toString('hex')}`;
+    const finalMetadata = { ...metadata, checksum: checksumHex };
+    const metadataBytes = Buffer.from(JSON.stringify(finalMetadata), 'utf-8');
+    const finalChecksum = computeChecksum(metadataBytes, bytecode, proto);
+    const signature = signFn ? signFn(finalChecksum) : Buffer.alloc(expectedSigSize);
     if (signature.length !== expectedSigSize) {
         throw new Error(`Signature size mismatch: expected ${expectedSigSize}, got ${signature.length}`);
     }
-    const metadataStr = JSON.stringify(metadata);
-    const metadataBytes = Buffer.from(metadataStr, 'utf-8');
-    const checksum = computeChecksum(metadataBytes, bytecode, proto);
     const totalSize = 8 +
         4 +
         1 +
@@ -140,8 +145,8 @@ export function buildOpnetBinary(options) {
     offset += 4;
     proto.copy(buffer, offset);
     offset += proto.length;
-    checksum.copy(buffer, offset);
-    return buffer;
+    finalChecksum.copy(buffer, offset);
+    return { binary: buffer, checksum: finalChecksum };
 }
 export function extractMetadata(data) {
     try {

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',