@btc-vision/cli 1.0.0

package/build/lib/binary.d.ts

@@ -0,0 +1,16 @@
+import { IParsedPluginFile, IPluginMetadata } from '@btc-vision/plugin-sdk';
+import { CLIMldsaLevel } from '../types/index.js';
+export declare function parseOpnetBinary(data: Buffer): IParsedPluginFile;
+export declare function computeChecksum(metadata: Buffer, bytecode: Buffer, proto: Buffer): Buffer;
+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;
+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

@@ -0,0 +1,165 @@
+import * as crypto from 'crypto';
+import { PLUGIN_MAGIC_BYTES, PLUGIN_FORMAT_VERSION, MLDSA_PUBLIC_KEY_SIZES, MLDSA_SIGNATURE_SIZES, } from '@btc-vision/plugin-sdk';
+import { cliLevelToMLDSALevel, mldsaLevelToCLI } from '../types/index.js';
+export function parseOpnetBinary(data) {
+    let offset = 0;
+    if (data.length < 8 + 4 + 1) {
+        throw new Error('Binary too small: missing header');
+    }
+    const magic = data.subarray(offset, offset + 8);
+    offset += 8;
+    if (!magic.equals(PLUGIN_MAGIC_BYTES)) {
+        throw new Error(`Invalid magic bytes: expected ${PLUGIN_MAGIC_BYTES.toString('hex')}, got ${magic.toString('hex')}`);
+    }
+    const formatVersion = data.readUInt32LE(offset);
+    offset += 4;
+    if (formatVersion !== PLUGIN_FORMAT_VERSION) {
+        throw new Error(`Unsupported format version: ${formatVersion} (expected ${PLUGIN_FORMAT_VERSION})`);
+    }
+    const mldsaLevelValue = data.readUInt8(offset);
+    offset += 1;
+    if (mldsaLevelValue > 2) {
+        throw new Error(`Invalid MLDSA level: ${mldsaLevelValue} (must be 0, 1, or 2)`);
+    }
+    const mldsaLevel = mldsaLevelValue;
+    const publicKeySize = MLDSA_PUBLIC_KEY_SIZES[mldsaLevel];
+    const signatureSize = MLDSA_SIGNATURE_SIZES[mldsaLevel];
+    const minSize = offset + publicKeySize + signatureSize + 4 + 4 + 4 + 32;
+    if (data.length < minSize) {
+        throw new Error(`Binary truncated: expected at least ${minSize} bytes, got ${data.length}`);
+    }
+    const publicKey = Buffer.from(data.subarray(offset, offset + publicKeySize));
+    offset += publicKeySize;
+    const signature = Buffer.from(data.subarray(offset, offset + signatureSize));
+    offset += signatureSize;
+    const metadataLength = data.readUInt32LE(offset);
+    offset += 4;
+    if (offset + metadataLength > data.length) {
+        throw new Error(`Metadata section truncated at offset ${offset}`);
+    }
+    const metadataBytes = data.subarray(offset, offset + metadataLength);
+    offset += metadataLength;
+    let rawMetadata;
+    let metadata;
+    try {
+        rawMetadata = metadataBytes.toString('utf-8');
+        metadata = JSON.parse(rawMetadata);
+    }
+    catch {
+        throw new Error('Malformed JSON metadata');
+    }
+    const bytecodeLength = data.readUInt32LE(offset);
+    offset += 4;
+    if (offset + bytecodeLength > data.length) {
+        throw new Error(`Bytecode section truncated at offset ${offset}`);
+    }
+    const bytecode = Buffer.from(data.subarray(offset, offset + bytecodeLength));
+    offset += bytecodeLength;
+    const protoLength = data.readUInt32LE(offset);
+    offset += 4;
+    if (offset + protoLength > data.length) {
+        throw new Error(`Proto section truncated at offset ${offset}`);
+    }
+    const proto = protoLength > 0 ? Buffer.from(data.subarray(offset, offset + protoLength)) : undefined;
+    offset += protoLength;
+    if (offset + 32 > data.length) {
+        throw new Error('Checksum truncated');
+    }
+    const checksum = Buffer.from(data.subarray(offset, offset + 32));
+    return {
+        formatVersion,
+        mldsaLevel,
+        publicKey,
+        signature,
+        metadata,
+        rawMetadata,
+        bytecode,
+        proto,
+        checksum,
+    };
+}
+export function computeChecksum(metadata, bytecode, proto) {
+    const hash = crypto.createHash('sha256');
+    hash.update(metadata);
+    hash.update(bytecode);
+    hash.update(proto);
+    return hash.digest();
+}
+export function verifyChecksum(parsed) {
+    const metadataBytes = Buffer.from(parsed.rawMetadata, 'utf-8');
+    const computed = computeChecksum(metadataBytes, parsed.bytecode, parsed.proto ?? Buffer.alloc(0));
+    return computed.equals(parsed.checksum);
+}
+export function buildOpnetBinary(options) {
+    const { mldsaLevel, publicKey, signature, metadata, bytecode, proto = Buffer.alloc(0) } = 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}`);
+    }
+    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 +
+        publicKey.length +
+        signature.length +
+        4 + metadataBytes.length +
+        4 + bytecode.length +
+        4 + proto.length +
+        32;
+    const buffer = Buffer.alloc(totalSize);
+    let offset = 0;
+    PLUGIN_MAGIC_BYTES.copy(buffer, offset);
+    offset += 8;
+    buffer.writeUInt32LE(PLUGIN_FORMAT_VERSION, offset);
+    offset += 4;
+    buffer.writeUInt8(sdkLevel, offset);
+    offset += 1;
+    publicKey.copy(buffer, offset);
+    offset += publicKey.length;
+    signature.copy(buffer, offset);
+    offset += signature.length;
+    buffer.writeUInt32LE(metadataBytes.length, offset);
+    offset += 4;
+    metadataBytes.copy(buffer, offset);
+    offset += metadataBytes.length;
+    buffer.writeUInt32LE(bytecode.length, offset);
+    offset += 4;
+    bytecode.copy(buffer, offset);
+    offset += bytecode.length;
+    buffer.writeUInt32LE(proto.length, offset);
+    offset += 4;
+    proto.copy(buffer, offset);
+    offset += proto.length;
+    checksum.copy(buffer, offset);
+    return buffer;
+}
+export function extractMetadata(data) {
+    try {
+        const parsed = parseOpnetBinary(data);
+        return parsed.metadata;
+    }
+    catch {
+        return null;
+    }
+}
+export function getParsedMldsaLevel(parsed) {
+    return mldsaLevelToCLI(parsed.mldsaLevel);
+}
+export function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+}

package/build/lib/config.d.ts

@@ -0,0 +1,11 @@
+import { CLIConfig, NetworkName, CLIMldsaLevel } from '../types/index.js';
+export declare function ensureConfigDir(): void;
+export declare function loadConfig(): CLIConfig;
+export declare function saveConfig(config: CLIConfig): void;
+export declare function getConfigValue(key: string): unknown;
+export declare function setConfigValue(key: string, value: unknown): void;
+export declare function getRpcUrl(network?: NetworkName): string;
+export declare function getRegistryAddress(network?: NetworkName): string;
+export declare function getDefaultMldsaLevel(): CLIMldsaLevel;
+export declare function getDefaultNetwork(): NetworkName;
+export declare function displayConfig(): string;

package/build/lib/config.js

@@ -0,0 +1,160 @@
+import * as fs from 'fs';
+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 = {
+    defaultNetwork: 'regtest',
+    rpcUrls: {
+        mainnet: 'https://api.opnet.org',
+        testnet: 'https://testnet.opnet.org',
+        regtest: 'https://regtest.opnet.org',
+    },
+    ipfsGateway: 'https://ipfs.opnet.org/ipfs/',
+    ipfsGateways: [
+        'https://ipfs.opnet.org/ipfs/',
+        'https://ipfs.io/ipfs/',
+        'https://cloudflare-ipfs.com/ipfs/',
+        'https://dweb.link/ipfs/',
+    ],
+    ipfsPinningEndpoint: 'https://ipfs.opnet.org/api/v0/add',
+    ipfsPinningApiKey: '',
+    ipfsPinningAuthHeader: 'Authorization',
+    registryAddresses: {
+        mainnet: '',
+        testnet: '',
+        regtest: '',
+    },
+    defaultMldsaLevel: 44,
+    indexerUrl: 'https://indexer.opnet.org',
+};
+function getEnvOverrides() {
+    const overrides = {};
+    if (process.env.OPNET_NETWORK) {
+        const network = process.env.OPNET_NETWORK;
+        if (['mainnet', 'testnet', 'regtest'].includes(network)) {
+            overrides.defaultNetwork = network;
+        }
+    }
+    if (process.env.OPNET_RPC_URL) {
+        const config = loadConfig();
+        overrides.rpcUrls = {
+            ...config.rpcUrls,
+            [config.defaultNetwork]: process.env.OPNET_RPC_URL,
+        };
+    }
+    if (process.env.OPNET_IPFS_GATEWAY) {
+        overrides.ipfsGateway = process.env.OPNET_IPFS_GATEWAY;
+    }
+    if (process.env.OPNET_IPFS_PINNING_ENDPOINT) {
+        overrides.ipfsPinningEndpoint = process.env.OPNET_IPFS_PINNING_ENDPOINT;
+    }
+    if (process.env.OPNET_IPFS_PINNING_KEY) {
+        overrides.ipfsPinningApiKey = process.env.OPNET_IPFS_PINNING_KEY;
+    }
+    if (process.env.OPNET_REGISTRY_ADDRESS) {
+        const config = loadConfig();
+        overrides.registryAddresses = {
+            ...config.registryAddresses,
+            [config.defaultNetwork]: process.env.OPNET_REGISTRY_ADDRESS,
+        };
+    }
+    if (process.env.OPNET_INDEXER_URL) {
+        overrides.indexerUrl = process.env.OPNET_INDEXER_URL;
+    }
+    return overrides;
+}
+export function ensureConfigDir() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export function loadConfig() {
+    ensureConfigDir();
+    let fileConfig = {};
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            fileConfig = JSON.parse(content);
+        }
+        catch {
+        }
+    }
+    const envOverrides = getEnvOverrides();
+    return {
+        ...DEFAULT_CONFIG,
+        ...fileConfig,
+        ...envOverrides,
+        rpcUrls: {
+            ...DEFAULT_CONFIG.rpcUrls,
+            ...fileConfig.rpcUrls,
+            ...envOverrides.rpcUrls,
+        },
+        ipfsGateways: fileConfig.ipfsGateways || DEFAULT_CONFIG.ipfsGateways,
+        registryAddresses: {
+            ...DEFAULT_CONFIG.registryAddresses,
+            ...fileConfig.registryAddresses,
+            ...envOverrides.registryAddresses,
+        },
+    };
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 4), { mode: 0o600 });
+}
+export function getConfigValue(key) {
+    const config = loadConfig();
+    const keys = key.split('.');
+    let value = config;
+    for (const k of keys) {
+        if (value && typeof value === 'object' && k in value) {
+            value = value[k];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+export function setConfigValue(key, value) {
+    const config = loadConfig();
+    const keys = key.split('.');
+    let target = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (!(k in target) || typeof target[k] !== 'object') {
+            target[k] = {};
+        }
+        target = target[k];
+    }
+    const finalKey = keys[keys.length - 1];
+    target[finalKey] = value;
+    saveConfig(config);
+}
+export function getRpcUrl(network) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    return config.rpcUrls[targetNetwork] || config.rpcUrls.mainnet;
+}
+export function getRegistryAddress(network) {
+    const config = loadConfig();
+    const targetNetwork = network || config.defaultNetwork;
+    const address = config.registryAddresses[targetNetwork];
+    if (!address) {
+        throw new Error(`Registry address not configured for network: ${targetNetwork}\n` +
+            `Run: opnet config set registryAddresses.${targetNetwork} <address>`);
+    }
+    return address;
+}
+export function getDefaultMldsaLevel() {
+    const config = loadConfig();
+    return config.defaultMldsaLevel;
+}
+export function getDefaultNetwork() {
+    const config = loadConfig();
+    return config.defaultNetwork;
+}
+export function displayConfig() {
+    const config = loadConfig();
+    return JSON.stringify(config, null, 2);
+}

package/build/lib/credentials.d.ts

@@ -0,0 +1,10 @@
+import { CLICredentials, NetworkName, CLIMldsaLevel } from '../types/index.js';
+export declare function loadCredentials(): CLICredentials | null;
+export declare function saveCredentials(credentials: CLICredentials): void;
+export declare function deleteCredentials(): boolean;
+export declare function hasCredentials(): boolean;
+export declare function canSign(credentials: CLICredentials | null): boolean;
+export declare function getCredentialSource(): string;
+export declare function maskSensitive(value: string, showChars?: number): string;
+export declare function isValidMldsaLevel(level: number): level is CLIMldsaLevel;
+export declare function isValidNetwork(network: string): network is NetworkName;

package/build/lib/credentials.js

@@ -0,0 +1,89 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ensureConfigDir } from './config.js';
+const CREDENTIALS_FILE = path.join(os.homedir(), '.opnet', 'credentials.json');
+export function loadCredentials() {
+    if (process.env.OPNET_MNEMONIC) {
+        return {
+            mnemonic: process.env.OPNET_MNEMONIC,
+            mldsaLevel: parseInt(process.env.OPNET_MLDSA_LEVEL || '44', 10) || 44,
+            network: process.env.OPNET_NETWORK || 'mainnet',
+        };
+    }
+    if (process.env.OPNET_PRIVATE_KEY || process.env.OPNET_MLDSA_KEY) {
+        return {
+            wif: process.env.OPNET_PRIVATE_KEY,
+            mldsaPrivateKey: process.env.OPNET_MLDSA_KEY,
+            mldsaLevel: parseInt(process.env.OPNET_MLDSA_LEVEL || '44', 10) || 44,
+            network: process.env.OPNET_NETWORK || 'mainnet',
+        };
+    }
+    if (!fs.existsSync(CREDENTIALS_FILE)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(CREDENTIALS_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(credentials) {
+    ensureConfigDir();
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 4), {
+        mode: 0o600,
+    });
+}
+export function deleteCredentials() {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+        fs.unlinkSync(CREDENTIALS_FILE);
+        return true;
+    }
+    return false;
+}
+export function hasCredentials() {
+    if (process.env.OPNET_MNEMONIC ||
+        process.env.OPNET_PRIVATE_KEY ||
+        process.env.OPNET_MLDSA_KEY) {
+        return true;
+    }
+    return fs.existsSync(CREDENTIALS_FILE);
+}
+export function canSign(credentials) {
+    if (!credentials) {
+        return false;
+    }
+    if (credentials.mnemonic) {
+        return true;
+    }
+    if (credentials.wif && credentials.mldsaPrivateKey) {
+        return true;
+    }
+    return false;
+}
+export function getCredentialSource() {
+    if (process.env.OPNET_MNEMONIC) {
+        return 'environment (OPNET_MNEMONIC)';
+    }
+    if (process.env.OPNET_PRIVATE_KEY || process.env.OPNET_MLDSA_KEY) {
+        return 'environment (OPNET_PRIVATE_KEY/OPNET_MLDSA_KEY)';
+    }
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+        return CREDENTIALS_FILE;
+    }
+    return 'none';
+}
+export function maskSensitive(value, showChars = 4) {
+    if (value.length <= showChars * 2) {
+        return '*'.repeat(value.length);
+    }
+    return value.slice(0, showChars) + '...' + value.slice(-showChars);
+}
+export function isValidMldsaLevel(level) {
+    return level === 44 || level === 65 || level === 87;
+}
+export function isValidNetwork(network) {
+    return network === 'mainnet' || network === 'testnet' || network === 'regtest';
+}

package/build/lib/ipfs.d.ts

@@ -0,0 +1,16 @@
+export interface PinResult {
+    cid: string;
+    size: number;
+}
+export interface FetchResult {
+    data: Buffer;
+    size: number;
+}
+export declare function pinToIPFS(data: Buffer, name?: string): Promise<PinResult>;
+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 downloadPlugin(cid: string, outputPath: string): Promise<number>;
+export declare function uploadPlugin(filePath: string): Promise<PinResult>;
+export declare function checkAvailability(cid: string): Promise<boolean>;
+export declare function getGatewayStatus(): Promise<Record<string, boolean>>;

package/build/lib/ipfs.js

@@ -0,0 +1,209 @@
+import * as https from 'https';
+import * as http from 'http';
+import * as fs from 'fs';
+import { loadConfig } from './config.js';
+async function httpRequest(url, options) {
+    return new Promise((resolve, reject) => {
+        const parsedUrl = new URL(url);
+        const isHttps = parsedUrl.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const reqOptions = {
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port || (isHttps ? 443 : 80),
+            path: parsedUrl.pathname + parsedUrl.search,
+            method: options.method,
+            headers: options.headers || {},
+            timeout: options.timeout || 30000,
+        };
+        const req = lib.request(reqOptions, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            res.on('end', () => {
+                const body = Buffer.concat(chunks);
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve(body);
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage} - ${body.toString()}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+        if (options.body) {
+            req.write(options.body);
+        }
+        req.end();
+    });
+}
+export async function pinToIPFS(data, name) {
+    const config = loadConfig();
+    const endpoint = config.ipfsPinningEndpoint;
+    if (!endpoint) {
+        throw new Error('IPFS pinning endpoint not configured. Run `opnet config set ipfsPinningEndpoint <url>`');
+    }
+    const boundary = '----FormBoundary' + Math.random().toString(36).substring(2);
+    const fileName = name || 'plugin.opnet';
+    const formParts = [];
+    formParts.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n` +
+        `Content-Type: application/octet-stream\r\n\r\n`));
+    formParts.push(data);
+    formParts.push(Buffer.from('\r\n'));
+    formParts.push(Buffer.from(`--${boundary}--\r\n`));
+    const body = Buffer.concat(formParts);
+    const headers = {
+        'Content-Type': `multipart/form-data; boundary=${boundary}`,
+        'Content-Length': body.length.toString(),
+    };
+    if (config.ipfsPinningAuthHeader) {
+        const [headerName, headerValue] = config.ipfsPinningAuthHeader.split(':').map((s) => s.trim());
+        if (headerName && headerValue) {
+            headers[headerName] = headerValue;
+        }
+    }
+    else if (config.ipfsPinningApiKey) {
+        headers['Authorization'] = `Bearer ${config.ipfsPinningApiKey}`;
+    }
+    const url = new URL(endpoint);
+    let requestUrl;
+    if (url.hostname.includes('ipfs.opnet.org')) {
+        requestUrl = endpoint;
+    }
+    else if (url.hostname.includes('pinata')) {
+        requestUrl = 'https://api.pinata.cloud/pinning/pinFileToIPFS';
+        if (config.ipfsPinningApiKey) {
+            headers['pinata_api_key'] = config.ipfsPinningApiKey;
+        }
+    }
+    else if (url.hostname.includes('web3.storage') || url.hostname.includes('w3s.link')) {
+        requestUrl = endpoint.endsWith('/') ? endpoint + 'upload' : endpoint + '/upload';
+    }
+    else if (url.hostname.includes('nft.storage')) {
+        requestUrl = 'https://api.nft.storage/upload';
+    }
+    else if (url.pathname.includes('/api/v0/')) {
+        requestUrl = endpoint;
+    }
+    else {
+        requestUrl = endpoint.endsWith('/') ? endpoint + 'pins' : endpoint + '/pins';
+    }
+    const response = await httpRequest(requestUrl, {
+        method: 'POST',
+        headers,
+        body,
+        timeout: 120000,
+    });
+    const result = JSON.parse(response.toString());
+    let cid;
+    if (typeof result.IpfsHash === 'string') {
+        cid = result.IpfsHash;
+    }
+    else if (typeof result.cid === 'string') {
+        cid = result.cid;
+    }
+    else if (typeof result.Hash === 'string') {
+        cid = result.Hash;
+    }
+    else if (result.value && typeof result.value.cid === 'string') {
+        cid = result.value.cid;
+    }
+    if (!cid) {
+        throw new Error(`Failed to extract CID from pinning response: ${JSON.stringify(result)}`);
+    }
+    return {
+        cid,
+        size: data.length,
+    };
+}
+export async function fetchFromIPFS(cid) {
+    const config = loadConfig();
+    const gateways = config.ipfsGateways.length > 0 ? config.ipfsGateways : [config.ipfsGateway];
+    let lastError;
+    for (const gateway of gateways) {
+        try {
+            const url = buildGatewayUrl(gateway, cid);
+            const data = await httpRequest(url, {
+                method: 'GET',
+                timeout: 60000,
+            });
+            return {
+                data,
+                size: data.length,
+            };
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            continue;
+        }
+    }
+    throw new Error(`Failed to fetch from all gateways: ${lastError?.message}`);
+}
+export function buildGatewayUrl(gateway, cid) {
+    const base = gateway.replace(/\/$/, '');
+    if (base.includes('{cid}')) {
+        return base.replace('{cid}', cid);
+    }
+    else if (base.includes('/ipfs/')) {
+        return `${base}${cid}`;
+    }
+    else {
+        return `${base}/ipfs/${cid}`;
+    }
+}
+export function isValidCid(cid) {
+    if (cid.startsWith('Qm') && cid.length === 46) {
+        return /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/.test(cid);
+    }
+    else if (cid.startsWith('ba')) {
+        return /^ba[a-z2-7]{57,}$/.test(cid);
+    }
+    else if (cid.startsWith('b')) {
+        return cid.length >= 50;
+    }
+    return false;
+}
+export async function downloadPlugin(cid, outputPath) {
+    const result = await fetchFromIPFS(cid);
+    fs.writeFileSync(outputPath, result.data);
+    return result.size;
+}
+export async function uploadPlugin(filePath) {
+    const data = fs.readFileSync(filePath);
+    const fileName = filePath.split('/').pop() || 'plugin.opnet';
+    return pinToIPFS(data, fileName);
+}
+export async function checkAvailability(cid) {
+    try {
+        await fetchFromIPFS(cid);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getGatewayStatus() {
+    const config = loadConfig();
+    const gateways = config.ipfsGateways.length > 0 ? config.ipfsGateways : [config.ipfsGateway];
+    const testCid = 'QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn';
+    const status = {};
+    await Promise.all(gateways.map(async (gateway) => {
+        try {
+            const url = buildGatewayUrl(gateway, testCid);
+            await httpRequest(url, {
+                method: 'HEAD',
+                timeout: 10000,
+            });
+            status[gateway] = true;
+        }
+        catch {
+            status[gateway] = false;
+        }
+    }));
+    return status;
+}

package/build/lib/manifest.d.ts

@@ -0,0 +1,14 @@
+import { IPluginMetadata, IPluginPermissions, IValidationResult } from '@btc-vision/plugin-sdk';
+export declare function validatePluginName(name: string): string[];
+export declare function validateManifest(manifest: Partial<IPluginMetadata>): IValidationResult;
+export declare function validatePermissions(permissions: IPluginPermissions): string[];
+export declare function loadManifest(manifestPath: string): IPluginMetadata;
+export declare function saveManifest(manifestPath: string, manifest: IPluginMetadata): void;
+export declare function createManifest(options: {
+    name: string;
+    author: string;
+    email?: string;
+    description?: string;
+    pluginType: 'standalone' | 'library';
+}): IPluginMetadata;
+export declare function getManifestPath(dir?: string): string;