@btc-vision/cli 1.0.7 → 1.0.8

package/build/lib/ipfs.js

@@ -214,3 +214,122 @@ export async function uploadPlugin(filePath) {
     const fileName = filePath.split('/').pop() || 'plugin.opnet';
     return pinToIPFS(data, fileName);
 }
+function getAllFiles(dirPath, basePath = '') {
+    const files = [];
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = `${dirPath}/${entry.name}`;
+        const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            files.push(...getAllFiles(fullPath, relativePath));
+        }
+        else if (entry.isFile()) {
+            files.push({ path: relativePath, fullPath });
+        }
+    }
+    return files;
+}
+function getMimeType(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() || '';
+    const mimeTypes = {
+        html: 'text/html',
+        htm: 'text/html',
+        css: 'text/css',
+        js: 'application/javascript',
+        mjs: 'application/javascript',
+        json: 'application/json',
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        ico: 'image/x-icon',
+        webp: 'image/webp',
+        woff: 'font/woff',
+        woff2: 'font/woff2',
+        ttf: 'font/ttf',
+        eot: 'application/vnd.ms-fontobject',
+        txt: 'text/plain',
+        xml: 'application/xml',
+        pdf: 'application/pdf',
+        zip: 'application/zip',
+        wasm: 'application/wasm',
+    };
+    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');
+        }
+        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');
+        }
+        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())
+                continue;
+            const result = JSON.parse(line);
+            if (result.Hash && (result.Name === '' || !result.Name)) {
+                rootCid = result.Hash;
+            }
+            else if (result.Hash && !rootCid) {
+                rootCid = result.Hash;
+            }
+        }
+        if (!rootCid) {
+            throw new Error(`Failed to extract root CID from response`);
+        }
+        return {
+            cid: rootCid,
+            files: files.length,
+            totalSize,
+        };
+    }
+    catch (e) {
+        throw new Error(`IPFS directory upload failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+export async function uploadFile(filePath) {
+    const data = fs.readFileSync(filePath);
+    const fileName = filePath.split('/').pop() || 'file';
+    return pinToIPFS(data, fileName);
+}

package/build/lib/resolver.d.ts

@@ -0,0 +1,43 @@
+import { Address } from '@btc-vision/transaction';
+import { NetworkName } from '../types/index.js';
+import { IBtcResolver } from '../types/BtcResolver.js';
+export interface DomainInfo {
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+    ttl: bigint;
+}
+export interface SubdomainInfo {
+    exists: boolean;
+    owner: Address;
+    parentHash: Uint8Array;
+    ttl: bigint;
+}
+export interface ContenthashInfo {
+    hashType: number;
+    hashData: Uint8Array;
+    hashString: string;
+}
+export interface PendingTransferInfo {
+    pendingOwner: Address;
+    initiatedAt: bigint;
+}
+export declare function getResolverContractAddress(network?: NetworkName): string;
+export declare function getResolverContract(network?: NetworkName, sender?: Address): IBtcResolver;
+export declare function clearResolverCache(): void;
+export declare function getDomain(domainName: string, network?: NetworkName): Promise<DomainInfo | null>;
+export declare function getSubdomain(fullName: string, network?: NetworkName): Promise<SubdomainInfo | null>;
+export declare function getContenthash(name: string, network?: NetworkName): Promise<ContenthashInfo>;
+export declare function resolveName(name: string, network?: NetworkName): Promise<Address | null>;
+export declare function getPendingTransfer(domainName: string, network?: NetworkName): Promise<PendingTransferInfo | null>;
+export declare function getTreasuryAddress(network?: NetworkName): Promise<string>;
+export declare function getDomainPrice(domainName: string, network?: NetworkName): Promise<bigint>;
+export declare function getBaseDomainPrice(network?: NetworkName): Promise<bigint>;
+export declare function getContenthashTypeName(hashType: number): string;
+export declare function detectContenthashType(content: string): number | null;
+export declare function validateDomainName(domain: string): string | null;
+export declare function validateCIDv0(cid: string): string | null;
+export declare function validateCIDv1(cid: string): string | null;
+export declare function validateIPNS(ipnsId: string): string | null;
+export declare function isSubdomain(name: string): boolean;
+export declare function parseDomainName(fullName: string): string;

package/build/lib/resolver.js

@@ -0,0 +1,197 @@
+import { getContract } from 'opnet';
+import { CONTENTHASH_TYPE_CIDv0, CONTENTHASH_TYPE_CIDv1, CONTENTHASH_TYPE_IPNS, CONTENTHASH_TYPE_SHA256, } from '../types/BtcResolver.js';
+import { getProvider } from './provider.js';
+import { getNetwork } from './wallet.js';
+import { loadConfig } from './config.js';
+import { BTC_RESOLVER_ABI } from './BtcResolver.abi.js';
+const resolverCache = new Map();
+export function getResolverContractAddress(network) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    const address = config.resolverAddresses?.[targetNetwork];
+    if (!address) {
+        throw new Error(`Resolver address not configured for network: ${targetNetwork}\n` +
+            `Run: opnet config set resolverAddresses.${targetNetwork} <address>`);
+    }
+    return address;
+}
+export function getResolverContract(network, sender) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    const cacheKey = sender ? `${targetNetwork}:${sender.toHex()}` : targetNetwork;
+    const cached = resolverCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const provider = getProvider(targetNetwork);
+    const resolverAddress = getResolverContractAddress(targetNetwork);
+    const bitcoinNetwork = getNetwork(targetNetwork);
+    const contract = getContract(resolverAddress, BTC_RESOLVER_ABI, provider, bitcoinNetwork, sender);
+    resolverCache.set(cacheKey, contract);
+    return contract;
+}
+export function clearResolverCache() {
+    resolverCache.clear();
+}
+export async function getDomain(domainName, network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getDomain(domainName);
+    if (!result.properties.exists) {
+        return null;
+    }
+    return {
+        exists: result.properties.exists,
+        owner: result.properties.owner,
+        createdAt: result.properties.createdAt,
+        ttl: result.properties.ttl,
+    };
+}
+export async function getSubdomain(fullName, network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getSubdomain(fullName);
+    if (!result.properties.exists) {
+        return null;
+    }
+    return {
+        exists: result.properties.exists,
+        owner: result.properties.owner,
+        parentHash: result.properties.parentHash,
+        ttl: result.properties.ttl,
+    };
+}
+export async function getContenthash(name, network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getContenthash(name);
+    return {
+        hashType: result.properties.hashType,
+        hashData: result.properties.hashData,
+        hashString: result.properties.hashString,
+    };
+}
+export async function resolveName(name, network) {
+    const contract = getResolverContract(network);
+    const result = await contract.resolve(name);
+    const owner = result.properties.owner;
+    if (!owner || owner.toString() === '0'.repeat(64)) {
+        return null;
+    }
+    return owner;
+}
+export async function getPendingTransfer(domainName, network) {
+    const contract = getResolverContract(network);
+    try {
+        const result = await contract.getPendingTransfer(domainName);
+        const pendingOwner = result.properties.pendingOwner;
+        if (!pendingOwner || pendingOwner.toString() === '0'.repeat(64)) {
+            return null;
+        }
+        return {
+            pendingOwner,
+            initiatedAt: result.properties.initiatedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getTreasuryAddress(network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getTreasuryAddress();
+    return result.properties.treasuryAddress;
+}
+export async function getDomainPrice(domainName, network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getDomainPrice(domainName);
+    return result.properties.priceSats;
+}
+export async function getBaseDomainPrice(network) {
+    const contract = getResolverContract(network);
+    const result = await contract.getBaseDomainPrice();
+    return result.properties.priceSats;
+}
+export function getContenthashTypeName(hashType) {
+    switch (hashType) {
+        case CONTENTHASH_TYPE_CIDv0:
+            return 'CIDv0';
+        case CONTENTHASH_TYPE_CIDv1:
+            return 'CIDv1';
+        case CONTENTHASH_TYPE_IPNS:
+            return 'IPNS';
+        case CONTENTHASH_TYPE_SHA256:
+            return 'SHA256';
+        default:
+            return 'Unknown';
+    }
+}
+export function detectContenthashType(content) {
+    if (content.startsWith('Qm') && content.length === 46) {
+        return CONTENTHASH_TYPE_CIDv0;
+    }
+    if (content.startsWith('baf')) {
+        return CONTENTHASH_TYPE_CIDv1;
+    }
+    if (content.startsWith('k')) {
+        return CONTENTHASH_TYPE_IPNS;
+    }
+    if (/^[0-9a-fA-F]{64}$/.test(content)) {
+        return CONTENTHASH_TYPE_SHA256;
+    }
+    return null;
+}
+export function validateDomainName(domain) {
+    if (domain.length < 3) {
+        return 'Domain must be at least 3 characters';
+    }
+    if (domain.length > 63) {
+        return 'Domain must be at most 63 characters';
+    }
+    if (!/^[a-zA-Z0-9]/.test(domain)) {
+        return 'Domain must start with alphanumeric character';
+    }
+    if (!/[a-zA-Z0-9]$/.test(domain)) {
+        return 'Domain must end with alphanumeric character';
+    }
+    if (!/^[a-zA-Z0-9-]+$/.test(domain)) {
+        return 'Domain can only contain letters, numbers, and hyphens';
+    }
+    if (/--/.test(domain)) {
+        return 'Domain cannot contain consecutive hyphens';
+    }
+    return null;
+}
+export function validateCIDv0(cid) {
+    if (cid.length !== 46) {
+        return 'CIDv0 must be 46 characters';
+    }
+    if (!cid.startsWith('Qm')) {
+        return 'CIDv0 must start with "Qm"';
+    }
+    return null;
+}
+export function validateCIDv1(cid) {
+    if (cid.length < 50 || cid.length > 128) {
+        return 'CIDv1 must be 50-128 characters';
+    }
+    if (!cid.startsWith('baf')) {
+        return 'CIDv1 must start with "baf"';
+    }
+    return null;
+}
+export function validateIPNS(ipnsId) {
+    if (ipnsId.length < 50 || ipnsId.length > 128) {
+        return 'IPNS ID must be 50-128 characters';
+    }
+    if (!ipnsId.startsWith('k')) {
+        return 'IPNS ID must start with "k"';
+    }
+    return null;
+}
+export function isSubdomain(name) {
+    return name.includes('.');
+}
+export function parseDomainName(fullName) {
+    if (fullName.endsWith('.btc')) {
+        return fullName.slice(0, -4);
+    }
+    return fullName;
+}

package/build/types/BtcResolver.d.ts

@@ -0,0 +1,139 @@
+import { Address } from '@btc-vision/transaction';
+import { CallResult, IOP_NETContract, OPNetEvent } from 'opnet';
+export declare const CONTENTHASH_TYPE_CIDv0 = 1;
+export declare const CONTENTHASH_TYPE_CIDv1 = 2;
+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 type DomainRegisteredEvent = {
+    readonly domainHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type DomainTransferInitiatedEvent = {
+    readonly domainHash: bigint;
+    readonly currentOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type DomainTransferCompletedEvent = {
+    readonly domainHash: bigint;
+    readonly previousOwner: Address;
+    readonly newOwner: Address;
+    readonly timestamp: bigint;
+};
+export type DomainTransferCancelledEvent = {
+    readonly domainHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type SubdomainCreatedEvent = {
+    readonly parentDomainHash: bigint;
+    readonly subdomainHash: bigint;
+    readonly owner: Address;
+    readonly timestamp: bigint;
+};
+export type SubdomainDeletedEvent = {
+    readonly parentDomainHash: bigint;
+    readonly subdomainHash: bigint;
+    readonly timestamp: bigint;
+};
+export type ContenthashChangedEvent = {
+    readonly nameHash: bigint;
+    readonly contenthashType: number;
+    readonly timestamp: bigint;
+};
+export type ContenthashClearedEvent = {
+    readonly nameHash: bigint;
+    readonly timestamp: bigint;
+};
+export type TTLChangedEvent = {
+    readonly nameHash: bigint;
+    readonly oldTTL: bigint;
+    readonly newTTL: bigint;
+    readonly timestamp: bigint;
+};
+export type DomainPriceChangedEvent = {
+    readonly oldPrice: bigint;
+    readonly newPrice: bigint;
+    readonly timestamp: bigint;
+};
+export type TreasuryChangedEvent = {
+    readonly previousAddressHash: bigint;
+    readonly newAddressHash: bigint;
+    readonly timestamp: bigint;
+};
+export type SetTreasuryAddress = CallResult<{}, OPNetEvent<TreasuryChangedEvent>[]>;
+export type SetDomainPrice = CallResult<{}, OPNetEvent<DomainPriceChangedEvent>[]>;
+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 CreateSubdomain = CallResult<{}, OPNetEvent<SubdomainCreatedEvent>[]>;
+export type DeleteSubdomain = CallResult<{}, OPNetEvent<SubdomainDeletedEvent>[]>;
+export type SetContenthashCIDv0 = CallResult<{}, OPNetEvent<ContenthashChangedEvent>[]>;
+export type SetContenthashCIDv1 = CallResult<{}, OPNetEvent<ContenthashChangedEvent>[]>;
+export type SetContenthashIPNS = CallResult<{}, OPNetEvent<ContenthashChangedEvent>[]>;
+export type SetContenthashSHA256 = CallResult<{}, OPNetEvent<ContenthashChangedEvent>[]>;
+export type ClearContenthash = CallResult<{}, OPNetEvent<ContenthashClearedEvent>[]>;
+export type SetTTL = CallResult<{}, OPNetEvent<TTLChangedEvent>[]>;
+export type GetDomain = CallResult<{
+    exists: boolean;
+    owner: Address;
+    createdAt: bigint;
+    ttl: bigint;
+}, OPNetEvent<never>[]>;
+export type GetSubdomain = CallResult<{
+    exists: boolean;
+    owner: Address;
+    parentHash: Uint8Array;
+    ttl: bigint;
+}, OPNetEvent<never>[]>;
+export type GetContenthash = CallResult<{
+    hashType: number;
+    hashData: Uint8Array;
+    hashString: string;
+}, OPNetEvent<never>[]>;
+export type Resolve = CallResult<{
+    owner: Address;
+}, OPNetEvent<never>[]>;
+export type GetPendingTransfer = CallResult<{
+    pendingOwner: Address;
+    initiatedAt: bigint;
+}, OPNetEvent<never>[]>;
+export type GetTreasuryAddress = CallResult<{
+    treasuryAddress: string;
+}, OPNetEvent<never>[]>;
+export type GetDomainPrice = CallResult<{
+    priceSats: bigint;
+}, OPNetEvent<never>[]>;
+export type GetBaseDomainPrice = CallResult<{
+    priceSats: bigint;
+}, OPNetEvent<never>[]>;
+export interface IBtcResolver extends IOP_NETContract {
+    setTreasuryAddress(treasuryAddress: string): Promise<SetTreasuryAddress>;
+    setDomainPrice(priceSats: bigint): Promise<SetDomainPrice>;
+    registerDomain(domainName: string): Promise<RegisterDomain>;
+    initiateTransfer(domainName: string, newOwner: Address): Promise<InitiateTransfer>;
+    acceptTransfer(domainName: string): Promise<AcceptTransfer>;
+    cancelTransfer(domainName: string): Promise<CancelTransfer>;
+    createSubdomain(parentDomain: string, subdomainLabel: string, subdomainOwner: Address): Promise<CreateSubdomain>;
+    deleteSubdomain(parentDomain: string, subdomainLabel: string): Promise<DeleteSubdomain>;
+    setContenthashCIDv0(name: string, cid: string): Promise<SetContenthashCIDv0>;
+    setContenthashCIDv1(name: string, cid: string): Promise<SetContenthashCIDv1>;
+    setContenthashIPNS(name: string, ipnsId: string): Promise<SetContenthashIPNS>;
+    setContenthashSHA256(name: string, hash: Uint8Array): Promise<SetContenthashSHA256>;
+    clearContenthash(name: string): Promise<ClearContenthash>;
+    setTTL(name: string, ttl: bigint): Promise<SetTTL>;
+    getDomain(domainName: string): Promise<GetDomain>;
+    getSubdomain(fullName: string): Promise<GetSubdomain>;
+    getContenthash(name: string): Promise<GetContenthash>;
+    resolve(name: string): Promise<Resolve>;
+    getPendingTransfer(domainName: string): Promise<GetPendingTransfer>;
+    getTreasuryAddress(): Promise<GetTreasuryAddress>;
+    getDomainPrice(domainName: string): Promise<GetDomainPrice>;
+    getBaseDomainPrice(): Promise<GetBaseDomainPrice>;
+}

package/build/types/BtcResolver.js

@@ -0,0 +1,7 @@
+export const CONTENTHASH_TYPE_CIDv0 = 1;
+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;

package/build/types/index.d.ts

@@ -11,6 +11,7 @@ export interface CLIConfig {
     ipfsPinningSecret: string;
     ipfsPinningAuthHeader: string;
     registryAddresses: Record<NetworkName, string>;
+    resolverAddresses?: Record<NetworkName, string>;
     defaultMldsaLevel: CLIMldsaLevel;
     indexerUrl: string;
 }

package/package.json

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