@btc-vision/cli 1.0.9 → 1.0.11

package/build/commands/AcceptCommand.js

@@ -75,7 +75,7 @@ export class AcceptCommand extends BaseCommand {
                     process.exit(1);
                 }
                 if (acceptResult.estimatedGas) {
-                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} sats`);
+                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} gas`);
                 }
                 const receipt = await acceptResult.sendTransaction(txParams);
                 this.logger.log('');
@@ -132,7 +132,7 @@ export class AcceptCommand extends BaseCommand {
                     process.exit(1);
                 }
                 if (acceptResult.estimatedGas) {
-                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} sats`);
+                    this.logger.info(`Estimated gas: ${acceptResult.estimatedGas} gas`);
                 }
                 const receipt = await acceptResult.sendTransaction(txParams);
                 this.logger.log('');

package/build/commands/DeprecateCommand.js

@@ -1,6 +1,6 @@
 import { confirm, input } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getRegistryContract, 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';
@@ -107,7 +107,7 @@ export class DeprecateCommand extends BaseCommand {
                 process.exit(1);
             }
             if (deprecateResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${deprecateResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${deprecateResult.estimatedGas} gas`);
             }
             const receipt = await deprecateResult.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/DomainCommand.js

@@ -3,10 +3,50 @@ import { confirm } from '@inquirer/prompts';
 import { Logger } from '@btc-vision/logger';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
-import { getResolverContract, getDomain, getContenthash, getContenthashTypeName, validateDomainName, getTreasuryAddress, getDomainPrice, parseDomainName, } from '../lib/resolver.js';
+import { getContenthash, getContenthashTypeName, getDomain, getDomainPrice, getResolverContract, getTreasuryAddress, parseDomainName, validateDomainName, } from '../lib/resolver.js';
+import { DEFAULT_DOMAIN_PRICE_SATS, PREMIUM_TIER_0_PRICE_SATS, PREMIUM_TIER_1_PRICE_SATS, PREMIUM_TIER_2_PRICE_SATS, PREMIUM_TIER_3_PRICE_SATS, PREMIUM_TIER_4_PRICE_SATS, PREMIUM_TIER_5_PRICE_SATS, PREMIUM_TIER_6_PRICE_SATS, } from '../types/BtcResolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 import { TransactionOutputFlags } from 'opnet';
 const logger = new Logger();
+function getPricingTierName(price) {
+    if (price >= PREMIUM_TIER_0_PRICE_SATS) {
+        return {
+            tier: 'Ultra Legendary (Tier 0)',
+            description: '10 BTC - Iconic crypto/tech names',
+        };
+    }
+    if (price >= PREMIUM_TIER_1_PRICE_SATS) {
+        return {
+            tier: 'Legendary (Tier 1)',
+            description: '1 BTC - Single character or top keywords',
+        };
+    }
+    if (price >= PREMIUM_TIER_2_PRICE_SATS) {
+        return {
+            tier: 'Premium (Tier 2)',
+            description: '0.25 BTC - Two character or major protocols',
+        };
+    }
+    if (price >= PREMIUM_TIER_3_PRICE_SATS) {
+        return {
+            tier: 'High Value (Tier 3)',
+            description: '0.1 BTC - Three character or valuable keywords',
+        };
+    }
+    if (price >= PREMIUM_TIER_4_PRICE_SATS) {
+        return {
+            tier: 'Valuable (Tier 4)',
+            description: '0.05 BTC - Four character or common keywords',
+        };
+    }
+    if (price >= PREMIUM_TIER_5_PRICE_SATS) {
+        return { tier: 'Common Premium (Tier 5)', description: '0.01 BTC - Five character domain' };
+    }
+    if (price >= PREMIUM_TIER_6_PRICE_SATS) {
+        return { tier: 'Notable (Tier 6)', description: '0.005 BTC - Notable keyword' };
+    }
+    return { tier: 'Standard', description: '0.001 BTC - Standard domain (6+ chars)' };
+}
 async function registerDomain(domain, options) {
     try {
         const network = (options.network || 'mainnet');
@@ -33,12 +73,11 @@ async function registerDomain(domain, options) {
         logger.success(`Domain ${displayName} is available`);
         const price = await getDomainPrice(name, network);
         const treasuryAddr = await getTreasuryAddress(network);
+        const pricingTier = getPricingTierName(price);
         logger.info(`Registration price: ${formatSats(price)}`);
-        if (name.length === 3) {
-            logger.warn('Premium pricing applied (3-character domain)');
-        }
-        else if (name.length === 4) {
-            logger.warn('Premium pricing applied (4-character domain)');
+        if (price > DEFAULT_DOMAIN_PRICE_SATS) {
+            logger.warn(`Premium pricing: ${pricingTier.tier}`);
+            logger.info(`  ${pricingTier.description}`);
         }
         logger.info('Loading wallet...');
         const credentials = loadCredentials();
@@ -109,7 +148,7 @@ async function registerDomain(domain, options) {
             process.exit(1);
         }
         if (registerResult.estimatedGas) {
-            logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+            logger.info(`Estimated gas: ${registerResult.estimatedGas} gas`);
         }
         const txParams = buildTransactionParams(wallet, network, DEFAULT_MAX_SAT_TO_SPEND + price, DEFAULT_FEE_RATE, extraUtxo);
         const receipt = await registerResult.sendTransaction(txParams);
@@ -160,21 +199,15 @@ async function domainInfo(domain, options) {
         if (!domainData) {
             logger.warn(`Domain ${displayName} is not registered`);
             const price = await getDomainPrice(name, network);
+            const pricingTier = getPricingTierName(price);
             logger.log('');
             logger.info('Registration Info');
             logger.log('-'.repeat(50));
             logger.log(`Domain:       ${displayName}`);
             logger.log(`Status:       Available`);
             logger.log(`Price:        ${formatSats(price)}`);
-            if (name.length === 3) {
-                logger.log(`Pricing tier: Premium (3-character)`);
-            }
-            else if (name.length === 4) {
-                logger.log(`Pricing tier: Premium (4-character)`);
-            }
-            else {
-                logger.log(`Pricing tier: Standard`);
-            }
+            logger.log(`Pricing tier: ${pricingTier.tier}`);
+            logger.log(`              ${pricingTier.description}`);
             logger.log('');
             logger.info('Register with:');
             logger.log(`  opnet domain register ${name} -n ${network}`);
@@ -222,8 +255,7 @@ async function domainInfo(domain, options) {
         process.exit(1);
     }
 }
-const domainCommand = new Command('domain')
-    .description('Manage .btc domains');
+const domainCommand = new Command('domain').description('Manage .btc domains');
 domainCommand
     .command('register')
     .description('Register a new .btc domain')

package/build/commands/PublishCommand.js

@@ -160,7 +160,7 @@ export class PublishCommand extends BaseCommand {
                     process.exit(1);
                 }
                 if (registerResult.estimatedGas) {
-                    this.logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+                    this.logger.info(`Estimated gas: ${registerResult.estimatedGas} gas`);
                 }
                 const registerReceipt = await registerResult.sendTransaction(txParams);
                 this.logger.success('Package registration transaction sent');
@@ -191,7 +191,7 @@ export class PublishCommand extends BaseCommand {
                 process.exit(1);
             }
             if (publishResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${publishResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${publishResult.estimatedGas} gas`);
             }
             const publishReceipt = await publishResult.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/ScopeRegisterCommand.js

@@ -88,7 +88,7 @@ export class ScopeRegisterCommand extends BaseCommand {
                 process.exit(1);
             }
             if (registerResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${registerResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${registerResult.estimatedGas} gas`);
             }
             const receipt = await registerResult.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/TransferCommand.js

@@ -111,7 +111,7 @@ export class TransferCommand extends BaseCommand {
                     process.exit(1);
                 }
                 if (transferResult.estimatedGas) {
-                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} gas`);
                 }
                 const receipt = await transferResult.sendTransaction(txParams);
                 this.logger.log('');
@@ -132,7 +132,7 @@ export class TransferCommand extends BaseCommand {
                     process.exit(1);
                 }
                 if (transferResult.estimatedGas) {
-                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} sats`);
+                    this.logger.info(`Estimated gas: ${transferResult.estimatedGas} gas`);
                 }
                 const receipt = await transferResult.sendTransaction(txParams);
                 this.logger.log('');
@@ -203,7 +203,7 @@ export class TransferCommand extends BaseCommand {
                 process.exit(1);
             }
             if (cancelResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} gas`);
             }
             const receipt = await cancelResult.sendTransaction(txParams);
             this.logger.log('');
@@ -251,7 +251,7 @@ export class TransferCommand extends BaseCommand {
                 process.exit(1);
             }
             if (cancelResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${cancelResult.estimatedGas} gas`);
             }
             const receipt = await cancelResult.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/UndeprecateCommand.js

@@ -1,6 +1,6 @@
 import { confirm } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
-import { getPackage, getRegistryContract, 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';
@@ -91,7 +91,7 @@ export class UndeprecateCommand extends BaseCommand {
                 process.exit(1);
             }
             if (undeprecateResult.estimatedGas) {
-                this.logger.info(`Estimated gas: ${undeprecateResult.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${undeprecateResult.estimatedGas} gas`);
             }
             const receipt = await undeprecateResult.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/WebsiteDeployCommand.js

@@ -6,7 +6,7 @@ import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
 import { uploadDirectory, uploadFile } from '../lib/ipfs.js';
 import { formatFileSize } from '../lib/binary.js';
-import { getResolverContract, getDomain, getSubdomain, getContenthash, getContenthashTypeName, isSubdomain, parseDomainName, } from '../lib/resolver.js';
+import { getContenthash, getContenthashTypeName, getDomain, getResolverContract, getSubdomain, isSubdomain, parseDomainName, } from '../lib/resolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 export class WebsiteDeployCommand extends BaseCommand {
     constructor() {
@@ -17,7 +17,7 @@ export class WebsiteDeployCommand extends BaseCommand {
             .argument('<domain>', 'Domain name (e.g., mysite or mysite.btc)')
             .argument('<path>', 'Path to website directory or HTML file')
             .option('-n, --network <network>', 'Network to use', 'mainnet')
-            .option('--dry-run', 'Upload to IPFS but don\'t update on-chain')
+            .option('--dry-run', "Upload to IPFS but don't update on-chain")
             .option('-y, --yes', 'Skip confirmation prompts')
             .action((domain, websitePath, options) => this.execute(domain, websitePath, options || { network: 'mainnet' }));
     }
@@ -144,7 +144,7 @@ export class WebsiteDeployCommand extends BaseCommand {
                 process.exit(1);
             }
             if (result.estimatedGas) {
-                this.logger.info(`Estimated gas: ${result.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${result.estimatedGas} gas`);
             }
             const receipt = await result.sendTransaction(txParams);
             this.logger.log('');

package/build/commands/WebsitePublishCommand.js

@@ -2,7 +2,7 @@ import { confirm } from '@inquirer/prompts';
 import { BaseCommand } from './BaseCommand.js';
 import { CLIWallet } from '../lib/wallet.js';
 import { canSign, loadCredentials } from '../lib/credentials.js';
-import { getResolverContract, getDomain, getSubdomain, getContenthash, detectContenthashType, validateCIDv0, validateCIDv1, validateIPNS, getContenthashTypeName, isSubdomain, parseDomainName, } from '../lib/resolver.js';
+import { detectContenthashType, getContenthash, getContenthashTypeName, getDomain, getResolverContract, getSubdomain, isSubdomain, parseDomainName, validateCIDv0, validateCIDv1, validateIPNS, } from '../lib/resolver.js';
 import { buildTransactionParams, checkBalance, DEFAULT_FEE_RATE, DEFAULT_MAX_SAT_TO_SPEND, formatSats, getWalletAddress, waitForTransactionConfirmation, } from '../lib/transaction.js';
 import { CONTENTHASH_TYPE_CIDv0, CONTENTHASH_TYPE_CIDv1, CONTENTHASH_TYPE_IPNS, CONTENTHASH_TYPE_SHA256, } from '../types/BtcResolver.js';
 export class WebsitePublishCommand extends BaseCommand {
@@ -188,7 +188,7 @@ export class WebsitePublishCommand extends BaseCommand {
                 process.exit(1);
             }
             if (result.estimatedGas) {
-                this.logger.info(`Estimated gas: ${result.estimatedGas} sats`);
+                this.logger.info(`Estimated gas: ${result.estimatedGas} gas`);
             }
             const receipt = await result.sendTransaction(txParams);
             this.logger.log('');

package/build/lib/BtcResolver.abi.js

@@ -40,6 +40,28 @@ export const BTC_RESOLVER_ABI = [
         inputs: [{ name: 'domainName', type: ABIDataTypes.STRING }],
         outputs: [],
     },
+    {
+        name: 'transferDomain',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'domainName', type: ABIDataTypes.STRING },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'transferDomainBySignature',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'ownerAddress', type: ABIDataTypes.BYTES32 },
+            { name: 'ownerTweakedPublicKey', type: ABIDataTypes.BYTES32 },
+            { name: 'domainName', type: ABIDataTypes.STRING },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'deadline', type: ABIDataTypes.UINT64 },
+            { name: 'signature', type: ABIDataTypes.BYTES },
+        ],
+        outputs: [],
+    },
     {
         name: 'createSubdomain',
         type: BitcoinAbiTypes.Function,

package/build/lib/config.js

@@ -24,7 +24,7 @@ export const DEFAULT_CONFIG = {
     resolverAddresses: {
         mainnet: '',
         testnet: '',
-        regtest: '0x336dcb0b117e29a61aef4856dc438f9951de39edcc4745a255713da8f807779c',
+        regtest: '0x84da2929ee0e5f4ac84d6910150b9ede78f912847496f8689ffad16c6e44cbbe',
     },
     defaultMldsaLevel: 44,
     indexerUrl: 'https://indexer.opnet.org',

package/build/lib/ipfs.d.ts

@@ -10,6 +10,9 @@ export declare function pinToIPFS(data: Buffer, name?: string): Promise<PinResul
 export declare function fetchFromIPFS(cid: string): Promise<FetchResult>;
 export declare function buildGatewayUrl(gateway: string, cid: string): string;
 export declare function isValidCid(cid: string): boolean;
+export declare function isCIDv0(cid: string): boolean;
+export declare function isCIDv1(cid: string): boolean;
+export declare function cidV0toV1(cidv0: string): string;
 export declare function downloadPlugin(cid: string, outputPath: string): Promise<number>;
 export declare function uploadPlugin(filePath: string): Promise<PinResult>;
 export interface DirectoryPinResult {
@@ -17,5 +20,5 @@ export interface DirectoryPinResult {
     files: number;
     totalSize: number;
 }
-export declare function uploadDirectory(dirPath: string, wrapWithDirectory?: boolean): Promise<DirectoryPinResult>;
+export declare function uploadDirectory(dirPath: string, _wrapWithDirectory?: boolean): Promise<DirectoryPinResult>;
 export declare function uploadFile(filePath: string): Promise<PinResult>;

package/build/lib/ipfs.js

@@ -1,6 +1,7 @@
 import * as https from 'https';
 import * as http from 'http';
 import * as fs from 'fs';
+import ora from 'ora';
 import { loadConfig } from './config.js';
 const DEFAULT_MAX_REDIRECTS = 10;
 async function httpRequest(url, options, redirectCount = 0) {
@@ -68,9 +69,37 @@ async function httpRequest(url, options, redirectCount = 0) {
             reject(new Error('Request timeout'));
         });
         if (options.body) {
-            req.write(options.body);
+            const bodyBuffer = Buffer.isBuffer(options.body) ? options.body : Buffer.from(options.body);
+            const totalBytes = bodyBuffer.length;
+            const chunkSize = 64 * 1024;
+            let bytesSent = 0;
+            const writeChunk = () => {
+                while (bytesSent < totalBytes) {
+                    const end = Math.min(bytesSent + chunkSize, totalBytes);
+                    const chunk = bodyBuffer.subarray(bytesSent, end);
+                    const canContinue = req.write(chunk);
+                    bytesSent += chunk.length;
+                    if (options.onProgress) {
+                        options.onProgress(bytesSent, totalBytes);
+                    }
+                    if (!canContinue) {
+                        req.once('drain', writeChunk);
+                        return;
+                    }
+                }
+                if (options.onUploadComplete) {
+                    options.onUploadComplete();
+                }
+                req.end();
+            };
+            writeChunk();
+        }
+        else {
+            if (options.onUploadComplete) {
+                options.onUploadComplete();
+            }
+            req.end();
         }
-        req.end();
     });
 }
 export async function pinToIPFS(data, name) {
@@ -156,6 +185,9 @@ export async function pinToIPFS(data, name) {
         if (!cid) {
             throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
         }
+        if (isCIDv0(cid)) {
+            cid = cidV0toV1(cid);
+        }
         return {
             cid,
             size: data.length,
@@ -219,6 +251,73 @@ export function isValidCid(cid) {
     }
     return false;
 }
+export function isCIDv0(cid) {
+    return cid.startsWith('Qm') && cid.length === 46;
+}
+export function isCIDv1(cid) {
+    return cid.startsWith('baf') && cid.length >= 50;
+}
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+function decodeBase58(str) {
+    const bytes = [];
+    for (const char of str) {
+        const value = BASE58_ALPHABET.indexOf(char);
+        if (value === -1) {
+            throw new Error(`Invalid base58 character: ${char}`);
+        }
+        let carry = value;
+        for (let i = 0; i < bytes.length; i++) {
+            carry += bytes[i] * 58;
+            bytes[i] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    for (const char of str) {
+        if (char === '1') {
+            bytes.push(0);
+        }
+        else {
+            break;
+        }
+    }
+    return new Uint8Array(bytes.reverse());
+}
+function encodeBase32(bytes) {
+    let result = '';
+    let bits = 0;
+    let value = 0;
+    for (const byte of bytes) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            result += BASE32_ALPHABET[(value >> bits) & 0x1f];
+        }
+    }
+    if (bits > 0) {
+        result += BASE32_ALPHABET[(value << (5 - bits)) & 0x1f];
+    }
+    return result;
+}
+export function cidV0toV1(cidv0) {
+    if (!isCIDv0(cidv0)) {
+        return cidv0;
+    }
+    const multihash = decodeBase58(cidv0);
+    if (multihash[0] !== 0x12 || multihash[1] !== 0x20 || multihash.length !== 34) {
+        throw new Error('Invalid CIDv0: not a valid sha2-256 multihash');
+    }
+    const cidv1Bytes = new Uint8Array(2 + multihash.length);
+    cidv1Bytes[0] = 0x01;
+    cidv1Bytes[1] = 0x70;
+    cidv1Bytes.set(multihash, 2);
+    return 'b' + encodeBase32(cidv1Bytes);
+}
 export async function downloadPlugin(cid, outputPath) {
     const result = await fetchFromIPFS(cid);
     fs.writeFileSync(outputPath, result.data);
@@ -272,74 +371,176 @@ function getMimeType(filePath) {
     };
     return mimeTypes[ext] || 'application/octet-stream';
 }
-export async function uploadDirectory(dirPath, wrapWithDirectory = true) {
-    try {
-        const config = loadConfig();
-        const endpoint = config.ipfsPinningEndpoint;
-        if (!endpoint) {
-            throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
-        }
-        const files = getAllFiles(dirPath);
-        if (files.length === 0) {
-            throw new Error('Directory is empty');
-        }
+function generateSessionId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function mfsCall(endpoint, apiPath, params, body, headers, maxRetries = 3) {
+    const url = new URL(endpoint);
+    url.pathname = apiPath;
+    for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+    }
+    const reqHeaders = {
+        ...headers,
+    };
+    let formBody;
+    if (body) {
         const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
         const formParts = [];
-        let totalSize = 0;
-        for (const file of files) {
-            const data = fs.readFileSync(file.fullPath);
-            totalSize += data.length;
-            const mimeType = getMimeType(file.path);
-            formParts.push(Buffer.from(`--${boundary}\r\n` +
-                `Content-Disposition: form-data; name="file"; filename="${file.path}"\r\n` +
-                `Content-Type: ${mimeType}\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.ipfsPinningApiKey) {
-            headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
-        }
-        const url = new URL(endpoint);
-        if (wrapWithDirectory) {
-            url.searchParams.set('wrap-with-directory', 'true');
+        formParts.push(Buffer.from(`--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="file"\r\n` +
+            `Content-Type: application/octet-stream\r\n\r\n`));
+        formParts.push(body);
+        formParts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        formBody = Buffer.concat(formParts);
+        reqHeaders['Content-Type'] = `multipart/form-data; boundary=${boundary}`;
+        reqHeaders['Content-Length'] = formBody.length.toString();
+    }
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await httpRequest(url.toString(), {
+                method: 'POST',
+                headers: reqHeaders,
+                body: formBody,
+                timeout: body ? 120000 : 60000,
+                followRedirect: true,
+            });
         }
-        url.searchParams.set('cid-version', '1');
-        const response = await httpRequest(url.toString(), {
-            method: 'POST',
-            headers,
-            body,
-            timeout: 300000,
-            followRedirect: true,
-        });
-        const lines = response.toString().trim().split('\n');
-        let rootCid;
-        for (const line of lines) {
-            if (!line.trim())
+        catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+            if (lastError.message.includes('429')) {
+                const backoffMs = Math.pow(2, attempt) * 1000;
+                await sleep(backoffMs);
                 continue;
-            const result = JSON.parse(line);
-            if (result.Hash && (result.Name === '' || !result.Name)) {
-                rootCid = result.Hash;
             }
-            else if (result.Hash && !rootCid) {
-                rootCid = result.Hash;
+            throw lastError;
+        }
+    }
+    throw lastError || new Error('Max retries exceeded');
+}
+export async function uploadDirectory(dirPath, _wrapWithDirectory = true) {
+    const config = loadConfig();
+    const endpoint = config.ipfsPinningEndpoint;
+    if (!endpoint) {
+        throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
+    }
+    const baseUrl = endpoint.replace(/\/api\/v0\/add\/?$/, '');
+    const files = getAllFiles(dirPath);
+    if (files.length === 0) {
+        throw new Error('Directory is empty');
+    }
+    let totalSize = 0;
+    for (const file of files) {
+        const stat = fs.statSync(file.fullPath);
+        totalSize += stat.size;
+    }
+    const sessionId = generateSessionId();
+    const mfsPath = `/uploads/${sessionId}`;
+    const headers = {};
+    if (config.ipfsPinningApiKey) {
+        headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
+    }
+    const formatBytes = (bytes) => {
+        if (bytes < 1024)
+            return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    };
+    let uploadedBytes = 0;
+    let spinner = null;
+    try {
+        await mfsCall(baseUrl, '/api/v0/files/mkdir', {
+            arg: mfsPath,
+            parents: 'true',
+        }, undefined, headers);
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const data = fs.readFileSync(file.fullPath);
+            const fileMfsPath = `${mfsPath}/${file.path}`;
+            const parentDir = fileMfsPath.substring(0, fileMfsPath.lastIndexOf('/'));
+            if (parentDir !== mfsPath) {
+                await mfsCall(baseUrl, '/api/v0/files/mkdir', {
+                    arg: parentDir,
+                    parents: 'true',
+                }, undefined, headers);
             }
+            await mfsCall(baseUrl, '/api/v0/files/write', {
+                arg: fileMfsPath,
+                create: 'true',
+                parents: 'true',
+                truncate: 'true',
+            }, data, headers);
+            uploadedBytes += data.length;
+            const percent = Math.round((uploadedBytes / totalSize) * 100);
+            const barWidth = 30;
+            const filled = Math.round((percent / 100) * barWidth);
+            const empty = barWidth - filled;
+            const bar = '█'.repeat(filled) + '░'.repeat(empty);
+            process.stdout.write(`\r  Uploading: [${bar}] ${percent}% - ${i + 1}/${files.length} files (${formatBytes(uploadedBytes)}/${formatBytes(totalSize)})`);
         }
-        if (!rootCid) {
-            throw new Error(`Failed to extract root CID from response`);
+        process.stdout.write('\n');
+        spinner = ora({
+            text: 'Getting directory CID...',
+            spinner: 'dots',
+        }).start();
+        const statResponse = await mfsCall(baseUrl, '/api/v0/files/stat', {
+            arg: mfsPath,
+            hash: 'true',
+            'cid-base': 'base32',
+        }, undefined, headers);
+        const statResult = JSON.parse(statResponse.toString());
+        let cid = statResult.Hash;
+        if (!cid) {
+            spinner.fail('Failed to get directory CID');
+            throw new Error('MFS stat did not return a Hash');
+        }
+        if (isCIDv0(cid)) {
+            cid = cidV0toV1(cid);
+        }
+        spinner.text = 'Pinning content...';
+        try {
+            await mfsCall(baseUrl, '/api/v0/pin/add', {
+                arg: cid,
+            }, undefined, headers);
+        }
+        catch {
+        }
+        spinner.succeed(`Upload complete: ${cid}`);
+        try {
+            await mfsCall(baseUrl, '/api/v0/files/rm', {
+                arg: mfsPath,
+                recursive: 'true',
+            }, undefined, headers);
+        }
+        catch {
         }
         return {
-            cid: rootCid,
+            cid,
             files: files.length,
             totalSize,
         };
     }
     catch (e) {
+        if (spinner) {
+            spinner.fail('Upload failed');
+        }
+        try {
+            await mfsCall(baseUrl, '/api/v0/files/rm', {
+                arg: mfsPath,
+                recursive: 'true',
+            }, undefined, headers);
+        }
+        catch {
+        }
         throw new Error(`IPFS directory upload failed: ${e instanceof Error ? e.message : String(e)}`);
     }
 }

package/build/lib/resolver.js

@@ -139,8 +139,8 @@ export function detectContenthashType(content) {
     return null;
 }
 export function validateDomainName(domain) {
-    if (domain.length < 3) {
-        return 'Domain must be at least 3 characters';
+    if (domain.length < 1) {
+        return 'Domain must be at least 1 character';
     }
     if (domain.length > 63) {
         return 'Domain must be at most 63 characters';

package/build/types/BtcResolver.d.ts

@@ -6,8 +6,27 @@ export declare const CONTENTHASH_TYPE_IPNS = 3;
 export declare const CONTENTHASH_TYPE_SHA256 = 4;
 export type ContenthashType = typeof CONTENTHASH_TYPE_CIDv0 | typeof CONTENTHASH_TYPE_CIDv1 | typeof CONTENTHASH_TYPE_IPNS | typeof CONTENTHASH_TYPE_SHA256;
 export declare const DEFAULT_DOMAIN_PRICE_SATS = 100000n;
-export declare const PREMIUM_3_CHAR_PRICE_SATS = 1000000n;
-export declare const PREMIUM_4_CHAR_PRICE_SATS = 500000n;
+export declare const PREMIUM_TIER_0_PRICE_SATS = 1000000000n;
+export declare const PREMIUM_TIER_1_PRICE_SATS = 100000000n;
+export declare const PREMIUM_TIER_2_PRICE_SATS = 25000000n;
+export declare const PREMIUM_TIER_3_PRICE_SATS = 10000000n;
+export declare const PREMIUM_TIER_4_PRICE_SATS = 5000000n;
+export declare const PREMIUM_TIER_5_PRICE_SATS = 1000000n;
+export declare const PREMIUM_TIER_6_PRICE_SATS = 500000n;
+export declare const PREMIUM_TIER_0_DOMAINS: string[];
+export declare const PREMIUM_TIER_1_DOMAINS: string[];
+export declare const PREMIUM_TIER_2_DOMAINS: string[];
+export declare const PREMIUM_TIER_3_DOMAINS: string[];
+export declare const PREMIUM_TIER_4_DOMAINS: string[];
+export declare const PREMIUM_TIER_5_DOMAINS: string[];
+export declare const PREMIUM_TIER_6_DOMAINS: string[];
+export interface PricingTier {
+    tier: number;
+    name: string;
+    price: bigint;
+    description: string;
+}
+export declare function getPricingTier(domainName: string): PricingTier;
 export type DomainRegisteredEvent = {
     readonly domainHash: bigint;
     readonly owner: Address;
@@ -72,6 +91,8 @@ export type RegisterDomain = CallResult<{}, OPNetEvent<DomainRegisteredEvent>[]>
 export type InitiateTransfer = CallResult<{}, OPNetEvent<DomainTransferInitiatedEvent>[]>;
 export type AcceptTransfer = CallResult<{}, OPNetEvent<DomainTransferCompletedEvent>[]>;
 export type CancelTransfer = CallResult<{}, OPNetEvent<DomainTransferCancelledEvent>[]>;
+export type TransferDomain = CallResult<{}, OPNetEvent<DomainTransferCompletedEvent>[]>;
+export type TransferDomainBySignature = CallResult<{}, OPNetEvent<DomainTransferCompletedEvent>[]>;
 export type CreateSubdomain = CallResult<{}, OPNetEvent<SubdomainCreatedEvent>[]>;
 export type DeleteSubdomain = CallResult<{}, OPNetEvent<SubdomainDeletedEvent>[]>;
 export type SetContenthashCIDv0 = CallResult<{}, OPNetEvent<ContenthashChangedEvent>[]>;
@@ -120,6 +141,8 @@ export interface IBtcResolver extends IOP_NETContract {
     initiateTransfer(domainName: string, newOwner: Address): Promise<InitiateTransfer>;
     acceptTransfer(domainName: string): Promise<AcceptTransfer>;
     cancelTransfer(domainName: string): Promise<CancelTransfer>;
+    transferDomain(domainName: string, newOwner: Address): Promise<TransferDomain>;
+    transferDomainBySignature(ownerAddress: Uint8Array, ownerTweakedPublicKey: Uint8Array, domainName: string, newOwner: Address, deadline: bigint, signature: Uint8Array): Promise<TransferDomainBySignature>;
     createSubdomain(parentDomain: string, subdomainLabel: string, subdomainOwner: Address): Promise<CreateSubdomain>;
     deleteSubdomain(parentDomain: string, subdomainLabel: string): Promise<DeleteSubdomain>;
     setContenthashCIDv0(name: string, cid: string): Promise<SetContenthashCIDv0>;

package/build/types/BtcResolver.js

@@ -3,5 +3,161 @@ export const CONTENTHASH_TYPE_CIDv1 = 2;
 export const CONTENTHASH_TYPE_IPNS = 3;
 export const CONTENTHASH_TYPE_SHA256 = 4;
 export const DEFAULT_DOMAIN_PRICE_SATS = 100000n;
-export const PREMIUM_3_CHAR_PRICE_SATS = 1000000n;
-export const PREMIUM_4_CHAR_PRICE_SATS = 500000n;
+export const PREMIUM_TIER_0_PRICE_SATS = 1000000000n;
+export const PREMIUM_TIER_1_PRICE_SATS = 100000000n;
+export const PREMIUM_TIER_2_PRICE_SATS = 25000000n;
+export const PREMIUM_TIER_3_PRICE_SATS = 10000000n;
+export const PREMIUM_TIER_4_PRICE_SATS = 5000000n;
+export const PREMIUM_TIER_5_PRICE_SATS = 1000000n;
+export const PREMIUM_TIER_6_PRICE_SATS = 500000n;
+export const PREMIUM_TIER_0_DOMAINS = [
+    'satoshi', 'nakamoto', 'vitalik', 'cz', 'sbf', 'gavin', 'hal', 'finney',
+    'bitcoin', 'btc', 'ethereum', 'eth', 'crypto', 'blockchain', 'defi', 'web3',
+    'nft', 'dao', 'dex', 'cex', 'token', 'coin', 'wallet', 'exchange',
+    'binance', 'coinbase', 'kraken', 'gemini', 'ftx', 'bitfinex', 'bitstamp',
+    'huobi', 'okx', 'okex', 'kucoin', 'bybit', 'bitget', 'mexc', 'gateio',
+    'uniswap', 'aave', 'compound', 'maker', 'curve', 'sushi', 'pancakeswap',
+    'opensea', 'blur', 'looksrare', 'rarible', 'foundation',
+    'pepe', 'doge', 'shiba', 'shib', 'floki', 'bonk', 'wojak', 'meme',
+    'dogecoin', 'shibarium', 'babydoge',
+    'apple', 'google', 'amazon', 'microsoft', 'meta', 'facebook', 'twitter',
+    'tesla', 'nvidia', 'intel', 'amd', 'oracle', 'ibm', 'samsung',
+    'money', 'gold', 'bank', 'pay', 'cash', 'trade', 'invest', 'rich',
+    'moon', 'lambo', 'whale', 'alpha', 'sigma', 'chad', 'based',
+    'king', 'queen', 'god', 'lord', 'master', 'legend', 'epic', 'rare',
+];
+export const PREMIUM_TIER_1_DOMAINS = [
+    'swap', 'stake', 'yield', 'farm', 'pool', 'vault', 'bridge', 'layer',
+    'chain', 'block', 'hash', 'node', 'miner', 'validator', 'staker',
+    'solana', 'sol', 'cardano', 'ada', 'polkadot', 'dot', 'avalanche', 'avax',
+    'polygon', 'matic', 'arbitrum', 'arb', 'optimism', 'base', 'zksync',
+];
+export const PREMIUM_TIER_2_DOMAINS = [
+    'link', 'atom', 'near', 'algo', 'ftm', 'sand', 'mana', 'axs', 'ape',
+    'lido', 'rocket', 'eigen', 'blur', 'magic', 'looks', 'x2y2',
+    'safe', 'gnosis', 'ens', 'lens', 'punk', 'bayc', 'mayc', 'azuki',
+];
+export const PREMIUM_TIER_3_DOMAINS = [
+    'game', 'games', 'play', 'bet', 'casino', 'poker', 'dice', 'slots',
+    'news', 'media', 'blog', 'forum', 'chat', 'social', 'network',
+    'shop', 'store', 'market', 'buy', 'sell', 'auction', 'bid',
+];
+export const PREMIUM_TIER_4_DOMAINS = [
+    'john', 'james', 'david', 'michael', 'robert', 'william', 'richard',
+    'mary', 'jennifer', 'linda', 'elizabeth', 'barbara', 'susan', 'jessica',
+    'smith', 'johnson', 'williams', 'brown', 'jones', 'garcia', 'miller',
+];
+export const PREMIUM_TIER_5_DOMAINS = [
+    'hello', 'world', 'test', 'demo', 'example', 'sample', 'default',
+    'admin', 'user', 'guest', 'member', 'account', 'profile', 'settings',
+];
+export const PREMIUM_TIER_6_DOMAINS = [
+    'about', 'contact', 'help', 'support', 'faq', 'terms', 'privacy',
+    'home', 'index', 'main', 'start', 'begin', 'intro', 'welcome',
+];
+export function getPricingTier(domainName) {
+    const name = domainName.toLowerCase();
+    const len = name.length;
+    if (PREMIUM_TIER_0_DOMAINS.includes(name)) {
+        return {
+            tier: 0,
+            name: 'Ultra Legendary',
+            price: PREMIUM_TIER_0_PRICE_SATS,
+            description: '10 BTC - Iconic crypto/tech names',
+        };
+    }
+    if (len === 1) {
+        return {
+            tier: 1,
+            name: 'Legendary',
+            price: PREMIUM_TIER_1_PRICE_SATS,
+            description: '1 BTC - Single character domain',
+        };
+    }
+    if (len === 2) {
+        return {
+            tier: 2,
+            name: 'Premium',
+            price: PREMIUM_TIER_2_PRICE_SATS,
+            description: '0.25 BTC - Two character domain',
+        };
+    }
+    if (PREMIUM_TIER_1_DOMAINS.includes(name)) {
+        return {
+            tier: 1,
+            name: 'Legendary',
+            price: PREMIUM_TIER_1_PRICE_SATS,
+            description: '1 BTC - Top crypto keyword',
+        };
+    }
+    if (PREMIUM_TIER_2_DOMAINS.includes(name)) {
+        return {
+            tier: 2,
+            name: 'Premium',
+            price: PREMIUM_TIER_2_PRICE_SATS,
+            description: '0.25 BTC - Major protocol/project',
+        };
+    }
+    if (PREMIUM_TIER_3_DOMAINS.includes(name)) {
+        return {
+            tier: 3,
+            name: 'High Value',
+            price: PREMIUM_TIER_3_PRICE_SATS,
+            description: '0.1 BTC - High-value keyword',
+        };
+    }
+    if (PREMIUM_TIER_4_DOMAINS.includes(name)) {
+        return {
+            tier: 4,
+            name: 'Valuable',
+            price: PREMIUM_TIER_4_PRICE_SATS,
+            description: '0.05 BTC - Valuable keyword',
+        };
+    }
+    if (PREMIUM_TIER_5_DOMAINS.includes(name)) {
+        return {
+            tier: 5,
+            name: 'Common Premium',
+            price: PREMIUM_TIER_5_PRICE_SATS,
+            description: '0.01 BTC - Common keyword',
+        };
+    }
+    if (PREMIUM_TIER_6_DOMAINS.includes(name)) {
+        return {
+            tier: 6,
+            name: 'Notable',
+            price: PREMIUM_TIER_6_PRICE_SATS,
+            description: '0.005 BTC - Notable keyword',
+        };
+    }
+    if (len === 3) {
+        return {
+            tier: 3,
+            name: 'High Value',
+            price: PREMIUM_TIER_3_PRICE_SATS,
+            description: '0.1 BTC - Three character domain',
+        };
+    }
+    if (len === 4) {
+        return {
+            tier: 4,
+            name: 'Valuable',
+            price: PREMIUM_TIER_4_PRICE_SATS,
+            description: '0.05 BTC - Four character domain',
+        };
+    }
+    if (len === 5) {
+        return {
+            tier: 5,
+            name: 'Common Premium',
+            price: PREMIUM_TIER_5_PRICE_SATS,
+            description: '0.01 BTC - Five character domain',
+        };
+    }
+    return {
+        tier: 7,
+        name: 'Standard',
+        price: DEFAULT_DOMAIN_PRICE_SATS,
+        description: '0.001 BTC - Standard domain',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/cli",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "type": "module",
     "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
     "author": "OP_NET",