kynjal-cli 3.1.3 → 4.0.0

package/dist/src/transfer/ipfs/client.js

@@ -8,11 +8,56 @@
  * - Protocol Labs ipfs.io
  * - dweb.link (LibP2P)
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import * as crypto from 'crypto';
 /**
  * Available IPFS gateways in priority order
  */
-export const IPFS_GATEWAYS = [
+export var IPFS_GATEWAYS = [
     'https://gateway.pinata.cloud',
     'https://cloudflare-ipfs.com',
     'https://ipfs.io',
@@ -22,7 +67,7 @@ export const IPFS_GATEWAYS = [
 /**
  * IPNS resolvers
  */
-export const IPNS_RESOLVERS = [
+export var IPNS_RESOLVERS = [
     'https://gateway.pinata.cloud',
     'https://dweb.link',
     'https://ipfs.io',
@@ -34,56 +79,77 @@ export const IPNS_RESOLVERS = [
  * @param preferredGateway - Optional preferred gateway to try first
  * @returns CID string or null if resolution fails
  */
-export async function resolveIPNS(ipnsName, preferredGateway) {
-    const resolvers = preferredGateway
-        ? [preferredGateway, ...IPNS_RESOLVERS.filter(r => r !== preferredGateway)]
-        : IPNS_RESOLVERS;
-    console.log(`[IPFS] Resolving IPNS: ${ipnsName}`);
-    for (const gateway of resolvers) {
-        try {
-            const startTime = Date.now();
-            let cid = null;
-            // Method 1: DNSLink resolution for domain names
-            if (ipnsName.includes('.')) {
-                const response = await fetch(`${gateway}/api/v0/name/resolve?arg=/ipns/${ipnsName}`, {
-                    signal: AbortSignal.timeout(10000),
-                    headers: { 'Accept': 'application/json' },
-                });
-                if (response.ok) {
-                    const data = await response.json();
-                    cid = data.Path?.replace('/ipfs/', '') || null;
-                }
-            }
-            // Method 2: Direct IPNS key resolution via gateway redirect
-            if (!cid) {
-                const response = await fetch(`${gateway}/ipns/${ipnsName}`, {
-                    method: 'HEAD',
-                    signal: AbortSignal.timeout(10000),
-                    redirect: 'follow',
-                });
-                if (response.ok) {
-                    // Extract CID from the final URL after redirects
-                    const finalUrl = response.url;
-                    const cidMatch = finalUrl.match(/\/ipfs\/([a-zA-Z0-9]+)/);
-                    if (cidMatch) {
-                        cid = cidMatch[1];
+export function resolveIPNS(ipnsName, preferredGateway) {
+    var _a;
+    return __awaiter(this, void 0, Promise, function () {
+        var resolvers, _i, resolvers_1, gateway, startTime, cid, response, data, response, finalUrl, cidMatch, latency, error_1, errorMsg;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    resolvers = preferredGateway
+                        ? __spreadArray([preferredGateway], IPNS_RESOLVERS.filter(function (r) { return r !== preferredGateway; }), true) : IPNS_RESOLVERS;
+                    console.log("[IPFS] Resolving IPNS: " + ipnsName);
+                    _i = 0, resolvers_1 = resolvers;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < resolvers_1.length)) return [3 /*break*/, 10];
+                    gateway = resolvers_1[_i];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 8, , 9]);
+                    startTime = Date.now();
+                    cid = null;
+                    if (!ipnsName.includes('.')) return [3 /*break*/, 5];
+                    return [4 /*yield*/, fetch(gateway + "/api/v0/name/resolve?arg=/ipns/" + ipnsName, {
+                            signal: AbortSignal.timeout(10000),
+                            headers: { 'Accept': 'application/json' }
+                        })];
+                case 3:
+                    response = _b.sent();
+                    if (!response.ok) return [3 /*break*/, 5];
+                    return [4 /*yield*/, response.json()];
+                case 4:
+                    data = _b.sent();
+                    cid = ((_a = data.Path) === null || _a === void 0 ? void 0 : _a.replace('/ipfs/', '')) || null;
+                    _b.label = 5;
+                case 5:
+                    if (!!cid) return [3 /*break*/, 7];
+                    return [4 /*yield*/, fetch(gateway + "/ipns/" + ipnsName, {
+                            method: 'HEAD',
+                            signal: AbortSignal.timeout(10000),
+                            redirect: 'follow'
+                        })];
+                case 6:
+                    response = _b.sent();
+                    if (response.ok) {
+                        finalUrl = response.url;
+                        cidMatch = finalUrl.match(/\/ipfs\/([a-zA-Z0-9]+)/);
+                        if (cidMatch) {
+                            cid = cidMatch[1];
+                        }
                     }
-                }
-            }
-            if (cid) {
-                const latency = Date.now() - startTime;
-                console.log(`[IPFS] Resolved ${ipnsName} -> ${cid} via ${gateway} (${latency}ms)`);
-                return cid;
+                    _b.label = 7;
+                case 7:
+                    if (cid) {
+                        latency = Date.now() - startTime;
+                        console.log("[IPFS] Resolved " + ipnsName + " -> " + cid + " via " + gateway + " (" + latency + "ms)");
+                        return [2 /*return*/, cid];
+                    }
+                    return [3 /*break*/, 9];
+                case 8:
+                    error_1 = _b.sent();
+                    errorMsg = error_1 instanceof Error ? error_1.message : String(error_1);
+                    console.warn("[IPFS] Gateway " + gateway + " failed: " + errorMsg);
+                    return [3 /*break*/, 9];
+                case 9:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 10:
+                    console.warn("[IPFS] IPNS resolution failed for " + ipnsName + " on all gateways");
+                    return [2 /*return*/, null];
             }
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            console.warn(`[IPFS] Gateway ${gateway} failed: ${errorMsg}`);
-            continue;
-        }
-    }
-    console.warn(`[IPFS] IPNS resolution failed for ${ipnsName} on all gateways`);
-    return null;
+        });
+    });
 }
 /**
  * Fetch content from IPFS by CID with fallback across multiple gateways
@@ -92,138 +158,220 @@ export async function resolveIPNS(ipnsName, preferredGateway) {
  * @param preferredGateway - Optional preferred gateway to try first
  * @returns Parsed JSON content or null if fetch fails
  */
-export async function fetchFromIPFS(cid, preferredGateway) {
-    const gateways = preferredGateway
-        ? [preferredGateway, ...IPFS_GATEWAYS.filter(g => g !== preferredGateway)]
-        : IPFS_GATEWAYS;
-    console.log(`[IPFS] Fetching CID: ${cid}`);
-    for (const gateway of gateways) {
-        try {
-            const startTime = Date.now();
-            const url = `${gateway}/ipfs/${cid}`;
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(30000),
-                headers: {
-                    'Accept': 'application/json',
-                    'Cache-Control': 'max-age=3600',
-                },
-            });
-            if (response.ok) {
-                const data = await response.json();
-                const latency = Date.now() - startTime;
-                console.log(`[IPFS] Fetched ${cid} from ${gateway} (${latency}ms)`);
-                return data;
-            }
-            // Handle specific error codes
-            if (response.status === 504) {
-                console.warn(`[IPFS] Gateway timeout on ${gateway}, trying next...`);
-            }
-            else if (response.status === 429) {
-                console.warn(`[IPFS] Rate limited on ${gateway}, trying next...`);
+export function fetchFromIPFS(cid, preferredGateway) {
+    return __awaiter(this, void 0, Promise, function () {
+        var gateways, _i, gateways_1, gateway, startTime, url, response, data, latency, error_2, errorMsg;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isValidCID(cid))
+                        return [2 /*return*/, null];
+                    gateways = preferredGateway
+                        ? __spreadArray([preferredGateway], IPFS_GATEWAYS.filter(function (g) { return g !== preferredGateway; }), true) : IPFS_GATEWAYS;
+                    console.log("[IPFS] Fetching CID: " + cid);
+                    _i = 0, gateways_1 = gateways;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < gateways_1.length)) return [3 /*break*/, 8];
+                    gateway = gateways_1[_i];
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 6, , 7]);
+                    startTime = Date.now();
+                    url = gateway + "/ipfs/" + cid;
+                    return [4 /*yield*/, fetch(url, {
+                            signal: AbortSignal.timeout(30000),
+                            headers: {
+                                'Accept': 'application/json',
+                                'Cache-Control': 'max-age=3600'
+                            }
+                        })];
+                case 3:
+                    response = _a.sent();
+                    if (!response.ok) return [3 /*break*/, 5];
+                    return [4 /*yield*/, response.json()];
+                case 4:
+                    data = _a.sent();
+                    latency = Date.now() - startTime;
+                    console.log("[IPFS] Fetched " + cid + " from " + gateway + " (" + latency + "ms)");
+                    return [2 /*return*/, data];
+                case 5:
+                    // Handle specific error codes
+                    if (response.status === 504) {
+                        console.warn("[IPFS] Gateway timeout on " + gateway + ", trying next...");
+                    }
+                    else if (response.status === 429) {
+                        console.warn("[IPFS] Rate limited on " + gateway + ", trying next...");
+                    }
+                    return [3 /*break*/, 7];
+                case 6:
+                    error_2 = _a.sent();
+                    errorMsg = error_2 instanceof Error ? error_2.message : String(error_2);
+                    console.warn("[IPFS] Gateway " + gateway + " failed: " + errorMsg);
+                    return [3 /*break*/, 7];
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 8:
+                    console.warn("[IPFS] Fetch failed for " + cid + " on all gateways");
+                    return [2 /*return*/, null];
             }
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            console.warn(`[IPFS] Gateway ${gateway} failed: ${errorMsg}`);
-            continue;
-        }
-    }
-    console.warn(`[IPFS] Fetch failed for ${cid} on all gateways`);
-    return null;
+        });
+    });
 }
 /**
  * Fetch with full result metadata
  */
-export async function fetchFromIPFSWithMetadata(cid, preferredGateway) {
-    const gateways = preferredGateway
-        ? [preferredGateway, ...IPFS_GATEWAYS.filter(g => g !== preferredGateway)]
-        : IPFS_GATEWAYS;
-    for (const gateway of gateways) {
-        try {
-            const startTime = Date.now();
-            const url = `${gateway}/ipfs/${cid}`;
-            const response = await fetch(url, {
-                signal: AbortSignal.timeout(30000),
-                headers: {
-                    'Accept': 'application/json',
-                },
-            });
-            if (response.ok) {
-                const data = await response.json();
-                const latencyMs = Date.now() - startTime;
-                const cached = response.headers.get('X-Cache')?.includes('HIT') ||
-                    response.headers.get('CF-Cache-Status') === 'HIT';
-                return {
-                    data,
-                    gateway,
-                    cid,
-                    cached,
-                    latencyMs,
-                };
+export function fetchFromIPFSWithMetadata(cid, preferredGateway) {
+    var _a;
+    return __awaiter(this, void 0, Promise, function () {
+        var gateways, _i, gateways_2, gateway, startTime, url, response, data, latencyMs, cached, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!isValidCID(cid))
+                        return [2 /*return*/, null];
+                    gateways = preferredGateway
+                        ? __spreadArray([preferredGateway], IPFS_GATEWAYS.filter(function (g) { return g !== preferredGateway; }), true) : IPFS_GATEWAYS;
+                    _i = 0, gateways_2 = gateways;
+                    _c.label = 1;
+                case 1:
+                    if (!(_i < gateways_2.length)) return [3 /*break*/, 8];
+                    gateway = gateways_2[_i];
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 6, , 7]);
+                    startTime = Date.now();
+                    url = gateway + "/ipfs/" + cid;
+                    return [4 /*yield*/, fetch(url, {
+                            signal: AbortSignal.timeout(30000),
+                            headers: {
+                                'Accept': 'application/json'
+                            }
+                        })];
+                case 3:
+                    response = _c.sent();
+                    if (!response.ok) return [3 /*break*/, 5];
+                    return [4 /*yield*/, response.json()];
+                case 4:
+                    data = _c.sent();
+                    latencyMs = Date.now() - startTime;
+                    cached = ((_a = response.headers.get('X-Cache')) === null || _a === void 0 ? void 0 : _a.includes('HIT')) ||
+                        response.headers.get('CF-Cache-Status') === 'HIT';
+                    return [2 /*return*/, {
+                            data: data,
+                            gateway: gateway,
+                            cid: cid,
+                            cached: cached,
+                            latencyMs: latencyMs
+                        }];
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    _b = _c.sent();
+                    return [3 /*break*/, 7];
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 8: return [2 /*return*/, null];
             }
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
+        });
+    });
 }
 /**
  * Check if CID is pinned/available on a gateway
  */
-export async function isPinned(cid, gateway = 'https://ipfs.io') {
-    try {
-        const response = await fetch(`${gateway}/ipfs/${cid}`, {
-            method: 'HEAD',
-            signal: AbortSignal.timeout(5000),
+export function isPinned(cid, gateway) {
+    if (gateway === void 0) { gateway = 'https://ipfs.io'; }
+    return __awaiter(this, void 0, Promise, function () {
+        var response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!isValidCID(cid))
+                        return [2 /*return*/, false];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fetch(gateway + "/ipfs/" + cid, {
+                            method: 'HEAD',
+                            signal: AbortSignal.timeout(5000)
+                        })];
+                case 2:
+                    response = _b.sent();
+                    return [2 /*return*/, response.ok];
+                case 3:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
         });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
+    });
 }
 /**
  * Check availability across multiple gateways
  */
-export async function checkAvailability(cid) {
-    const results = await Promise.all(IPFS_GATEWAYS.map(async (gateway) => {
-        const startTime = Date.now();
-        try {
-            const response = await fetch(`${gateway}/ipfs/${cid}`, {
-                method: 'HEAD',
-                signal: AbortSignal.timeout(5000),
-            });
-            return {
-                url: gateway,
-                available: response.ok,
-                latencyMs: Date.now() - startTime,
-            };
-        }
-        catch {
-            return {
-                url: gateway,
-                available: false,
-                latencyMs: Date.now() - startTime,
-            };
-        }
-    }));
-    return {
-        available: results.some(r => r.available),
-        gateways: results,
-    };
+export function checkAvailability(cid) {
+    return __awaiter(this, void 0, Promise, function () {
+        var results;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!isValidCID(cid))
+                        return [2 /*return*/, { available: false, gateways: [] }];
+                    return [4 /*yield*/, Promise.all(IPFS_GATEWAYS.map(function (gateway) { return __awaiter(_this, void 0, void 0, function () {
+                            var startTime, response, _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        startTime = Date.now();
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, fetch(gateway + "/ipfs/" + cid, {
+                                                method: 'HEAD',
+                                                signal: AbortSignal.timeout(5000)
+                                            })];
+                                    case 2:
+                                        response = _b.sent();
+                                        return [2 /*return*/, {
+                                                url: gateway,
+                                                available: response.ok,
+                                                latencyMs: Date.now() - startTime
+                                            }];
+                                    case 3:
+                                        _a = _b.sent();
+                                        return [2 /*return*/, {
+                                                url: gateway,
+                                                available: false,
+                                                latencyMs: Date.now() - startTime
+                                            }];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 1:
+                    results = _a.sent();
+                    return [2 /*return*/, {
+                            available: results.some(function (r) { return r.available; }),
+                            gateways: results
+                        }];
+            }
+        });
+    });
 }
 /**
  * Get IPFS gateway URL for a CID
  */
-export function getGatewayUrl(cid, gateway = 'https://ipfs.io') {
-    return `${gateway}/ipfs/${cid}`;
+export function getGatewayUrl(cid, gateway) {
+    if (gateway === void 0) { gateway = 'https://ipfs.io'; }
+    return gateway + "/ipfs/" + cid;
 }
 /**
  * Get multiple gateway URLs for redundancy
  */
 export function getGatewayUrls(cid) {
-    return IPFS_GATEWAYS.map(gateway => `${gateway}/ipfs/${cid}`);
+    return IPFS_GATEWAYS.map(function (gateway) { return gateway + "/ipfs/" + cid; });
 }
 /**
  * Validate CID format (CIDv0 and CIDv1)
@@ -244,25 +392,35 @@ export function isValidIPNS(ipnsName) {
  * Generate content hash for verification
  */
 export function hashContent(content) {
-    const buffer = typeof content === 'string' ? Buffer.from(content) : content;
+    var buffer = typeof content === 'string' ? Buffer.from(content) : content;
     return crypto.createHash('sha256').update(buffer).digest('hex');
 }
 /**
  * Verify Ed25519 signature (async import to avoid bundling issues)
  */
-export async function verifyEd25519Signature(message, signature, publicKey) {
-    try {
-        // Dynamic import to avoid bundling @noble/ed25519 if not used
-        const ed = await import('@noble/ed25519');
-        // Handle prefixed public key (e.g., "ed25519:abc123...")
-        const pubKeyHex = publicKey.replace(/^ed25519:/, '');
-        const isValid = await ed.verifyAsync(Buffer.from(signature, 'hex'), new TextEncoder().encode(message), Buffer.from(pubKeyHex, 'hex'));
-        return isValid;
-    }
-    catch (error) {
-        console.warn('[IPFS] Signature verification failed:', error);
-        return false;
-    }
+export function verifyEd25519Signature(message, signature, publicKey) {
+    return __awaiter(this, void 0, Promise, function () {
+        var ed, pubKeyHex, isValid, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    return [4 /*yield*/, import('@noble/ed25519')];
+                case 1:
+                    ed = _a.sent();
+                    pubKeyHex = publicKey.replace(/^ed25519:/, '');
+                    return [4 /*yield*/, ed.verifyAsync(Buffer.from(signature, 'hex'), new TextEncoder().encode(message), Buffer.from(pubKeyHex, 'hex'))];
+                case 2:
+                    isValid = _a.sent();
+                    return [2 /*return*/, isValid];
+                case 3:
+                    error_3 = _a.sent();
+                    console.warn('[IPFS] Signature verification failed:', error_3);
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Parse CID to extract metadata
@@ -275,14 +433,14 @@ export function parseCID(cid) {
         return {
             version: 0,
             codec: 'dag-pb',
-            hash: cid,
+            hash: cid
         };
     }
     // CIDv1 - simplified parsing
     return {
         version: 1,
-        codec: 'dag-cbor', // Most common for JSON
-        hash: cid,
+        codec: 'dag-cbor',
+        hash: cid
     };
 }
 /**
@@ -291,9 +449,9 @@ export function parseCID(cid) {
 export function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+    var k = 1024;
+    var sizes = ['B', 'KB', 'MB', 'GB'];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
 }
 //# sourceMappingURL=client.js.map