@btc-vision/cli 1.0.10 → 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/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.10",
+    "version": "1.0.11",
     "type": "module",
     "description": "CLI for the OPNet plugin ecosystem - scaffolding, compilation, signing, and registry interaction",
     "author": "OP_NET",