kynjal-cli 4.0.0 → 4.0.1

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

@@ -8,56 +8,11 @@
  * - 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 var IPFS_GATEWAYS = [
+export const IPFS_GATEWAYS = [
     'https://gateway.pinata.cloud',
     'https://cloudflare-ipfs.com',
     'https://ipfs.io',
@@ -67,7 +22,7 @@ export var IPFS_GATEWAYS = [
 /**
  * IPNS resolvers
  */
-export var IPNS_RESOLVERS = [
+export const IPNS_RESOLVERS = [
     'https://gateway.pinata.cloud',
     'https://dweb.link',
     'https://ipfs.io',
@@ -79,77 +34,56 @@ export var IPNS_RESOLVERS = [
  * @param preferredGateway - Optional preferred gateway to try first
  * @returns CID string or null if resolution fails
  */
-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];
-                        }
-                    }
-                    _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];
+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];
                     }
-                    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];
+                }
             }
-        });
-    });
+            if (cid) {
+                const latency = Date.now() - startTime;
+                console.log(`[IPFS] Resolved ${ipnsName} -> ${cid} via ${gateway} (${latency}ms)`);
+                return cid;
+            }
+        }
+        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
@@ -158,220 +92,146 @@ export function resolveIPNS(ipnsName, preferredGateway) {
  * @param preferredGateway - Optional preferred gateway to try first
  * @returns Parsed JSON content or null if fetch fails
  */
-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];
+export async function fetchFromIPFS(cid, preferredGateway) {
+    if (!isValidCID(cid))
+        return null;
+    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...`);
+            }
+        }
+        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 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];
+export async function fetchFromIPFSWithMetadata(cid, preferredGateway) {
+    if (!isValidCID(cid))
+        return null;
+    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,
+                };
             }
-        });
-    });
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
 }
 /**
  * Check if CID is pinned/available on a gateway
  */
-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*/];
-            }
+export async function isPinned(cid, gateway = 'https://ipfs.io') {
+    if (!isValidCID(cid))
+        return false;
+    try {
+        const response = await fetch(`${gateway}/ipfs/${cid}`, {
+            method: 'HEAD',
+            signal: AbortSignal.timeout(5000),
         });
-    });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Check availability across multiple gateways
  */
-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
-                        }];
-            }
-        });
-    });
+export async function checkAvailability(cid) {
+    if (!isValidCID(cid))
+        return { available: false, gateways: [] };
+    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,
+    };
 }
 /**
  * Get IPFS gateway URL for a CID
  */
-export function getGatewayUrl(cid, gateway) {
-    if (gateway === void 0) { gateway = 'https://ipfs.io'; }
-    return gateway + "/ipfs/" + cid;
+export function getGatewayUrl(cid, gateway = 'https://ipfs.io') {
+    return `${gateway}/ipfs/${cid}`;
 }
 /**
  * Get multiple gateway URLs for redundancy
  */
 export function getGatewayUrls(cid) {
-    return IPFS_GATEWAYS.map(function (gateway) { return gateway + "/ipfs/" + cid; });
+    return IPFS_GATEWAYS.map(gateway => `${gateway}/ipfs/${cid}`);
 }
 /**
  * Validate CID format (CIDv0 and CIDv1)
@@ -392,35 +252,25 @@ export function isValidIPNS(ipnsName) {
  * Generate content hash for verification
  */
 export function hashContent(content) {
-    var buffer = typeof content === 'string' ? Buffer.from(content) : content;
+    const 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 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*/];
-            }
-        });
-    });
+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;
+    }
 }
 /**
  * Parse CID to extract metadata
@@ -433,14 +283,14 @@ export function parseCID(cid) {
         return {
             version: 0,
             codec: 'dag-pb',
-            hash: cid
+            hash: cid,
         };
     }
     // CIDv1 - simplified parsing
     return {
         version: 1,
-        codec: 'dag-cbor',
-        hash: cid
+        codec: 'dag-cbor', // Most common for JSON
+        hash: cid,
     };
 }
 /**
@@ -449,9 +299,9 @@ export function parseCID(cid) {
 export function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    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];
+    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]}`;
 }
 //# sourceMappingURL=client.js.map