@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-WRWEX5ZF.js

@@ -0,0 +1,658 @@
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+
+// src/storage/IPFSTypes.ts
+var IPFSUploadError = class extends Error {
+  constructor(message, provider, originalError) {
+    super(message);
+    this.provider = provider;
+    this.originalError = originalError;
+    this.name = "IPFSUploadError";
+  }
+};
+var IPFSPinError = class extends Error {
+  constructor(message, cid, originalError) {
+    super(message);
+    this.cid = cid;
+    this.originalError = originalError;
+    this.name = "IPFSPinError";
+  }
+};
+var FileSizeExceededError = class extends Error {
+  constructor(fileSize, maxSize) {
+    super(`File size ${fileSize} bytes exceeds maximum ${maxSize} bytes`);
+    this.fileSize = fileSize;
+    this.maxSize = maxSize;
+    this.name = "FileSizeExceededError";
+  }
+};
+
+// src/storage/IPFSProviders.ts
+init_safeJsonParse();
+var PinataProvider = class {
+  constructor(apiKey, apiSecret) {
+    this.baseUrl = "https://api.pinata.cloud";
+    this.apiKey = apiKey;
+    this.apiSecret = apiSecret || "";
+  }
+  async upload(files, options) {
+    const formData = new FormData();
+    for (const file of files) {
+      const blob = new Blob([file.content]);
+      formData.append("file", blob, file.path);
+    }
+    const metadata = {
+      name: options.metadata?.name || options.name,
+      keyvalues: options.metadata?.keyvalues || {}
+    };
+    formData.append("pinataMetadata", JSON.stringify(metadata));
+    const pinataOptions = {
+      cidVersion: 1
+    };
+    formData.append("pinataOptions", JSON.stringify(pinataOptions));
+    const response = await fetch(`${this.baseUrl}/pinning/pinFileToIPFS`, {
+      method: "POST",
+      headers: {
+        pinata_api_key: this.apiKey,
+        pinata_secret_api_key: this.apiSecret
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Pinata upload failed: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      cid: data.IpfsHash,
+      size: data.PinSize
+    };
+  }
+  async pin(cid, name) {
+    const response = await fetch(`${this.baseUrl}/pinning/pinByHash`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        pinata_api_key: this.apiKey,
+        pinata_secret_api_key: this.apiSecret
+      },
+      body: JSON.stringify({
+        hashToPin: cid,
+        pinataMetadata: {
+          name: name || cid
+        }
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Pinata pin failed: ${error}`);
+    }
+  }
+  async unpin(cid) {
+    const response = await fetch(`${this.baseUrl}/pinning/unpin/${cid}`, {
+      method: "DELETE",
+      headers: {
+        pinata_api_key: this.apiKey,
+        pinata_secret_api_key: this.apiSecret
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Pinata unpin failed: ${error}`);
+    }
+  }
+  async getPinStatus(cid) {
+    const response = await fetch(
+      `${this.baseUrl}/data/pinList?hashContains=${cid}&status=pinned,pinning`,
+      {
+        headers: {
+          pinata_api_key: this.apiKey,
+          pinata_secret_api_key: this.apiSecret
+        }
+      }
+    );
+    if (!response.ok) {
+      return "unpinned";
+    }
+    const data = await response.json();
+    if (data.count === 0) {
+      return "unpinned";
+    }
+    const pin = data.rows[0];
+    return pin.status === "pinned" ? "pinned" : "pinning";
+  }
+  async listPins() {
+    const response = await fetch(`${this.baseUrl}/data/pinList?status=pinned`, {
+      headers: {
+        pinata_api_key: this.apiKey,
+        pinata_secret_api_key: this.apiSecret
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to list pins");
+    }
+    const data = await response.json();
+    return data.rows.map((pin) => ({
+      // @ts-expect-error
+      cid: pin.ipfs_pin_hash,
+      // @ts-expect-error
+      name: pin.metadata?.name || pin.ipfs_pin_hash,
+      // @ts-expect-error
+      size: pin.size,
+      // @ts-expect-error
+      status: pin.status,
+      // @ts-expect-error
+      created: new Date(pin.date_pinned)
+    }));
+  }
+  async verifyCID(cid) {
+    try {
+      const status = await this.getPinStatus(cid);
+      return status === "pinned" || status === "pinning";
+    } catch {
+      return false;
+    }
+  }
+};
+var NFTStorageProvider = class {
+  constructor(apiKey) {
+    this.baseUrl = "https://api.nft.storage";
+    this.apiKey = apiKey;
+  }
+  async upload(files, options) {
+    const formData = new FormData();
+    for (const file of files) {
+      const blob = new Blob([file.content]);
+      formData.append("file", blob, file.path);
+    }
+    const response = await fetch(`${this.baseUrl}/upload`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`NFT.Storage upload failed: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      cid: data.value.cid,
+      size: data.value.size
+    };
+  }
+  async pin(cid, name) {
+  }
+  async unpin(cid) {
+    const response = await fetch(`${this.baseUrl}/${cid}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`NFT.Storage unpin failed: ${error}`);
+    }
+  }
+  async getPinStatus(cid) {
+    const response = await fetch(`${this.baseUrl}/${cid}`, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      return "unpinned";
+    }
+    const data = await response.json();
+    return data.pin?.status === "pinned" ? "pinned" : "pinning";
+  }
+  async listPins() {
+    const response = await fetch(`${this.baseUrl}`, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to list pins");
+    }
+    const data = await response.json();
+    return data.value.map((item) => ({
+      // @ts-expect-error
+      cid: item.cid,
+      // @ts-expect-error
+      name: item.name || item.cid,
+      // @ts-expect-error
+      size: item.size,
+      // @ts-expect-error
+      status: item.pin?.status || "pinned",
+      // @ts-expect-error
+      created: new Date(item.created)
+    }));
+  }
+  async verifyCID(cid) {
+    try {
+      const status = await this.getPinStatus(cid);
+      return status === "pinned" || status === "pinning";
+    } catch {
+      return false;
+    }
+  }
+};
+var InfuraProvider = class {
+  constructor(projectId, projectSecret) {
+    this.baseUrl = "https://ipfs.infura.io:5001/api/v0";
+    this.projectId = projectId;
+    this.projectSecret = projectSecret || "";
+  }
+  getAuthHeader() {
+    const auth = Buffer.from(`${this.projectId}:${this.projectSecret}`).toString("base64");
+    return `Basic ${auth}`;
+  }
+  async upload(files, options) {
+    const formData = new FormData();
+    for (const file of files) {
+      const blob = new Blob([file.content]);
+      formData.append("file", blob, file.path);
+    }
+    const response = await fetch(`${this.baseUrl}/add?wrap-with-directory=true`, {
+      method: "POST",
+      headers: {
+        Authorization: this.getAuthHeader()
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Infura upload failed: ${error}`);
+    }
+    const text = await response.text();
+    const lines = text.trim().split("\n");
+    const lastLine = readJson(lines[lines.length - 1]);
+    let totalSize = 0;
+    for (const line of lines) {
+      const data = readJson(line);
+      totalSize += data.Size || 0;
+    }
+    return {
+      cid: lastLine.Hash,
+      size: totalSize
+    };
+  }
+  async pin(cid, name) {
+    const response = await fetch(`${this.baseUrl}/pin/add?arg=${cid}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.getAuthHeader()
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Infura pin failed: ${error}`);
+    }
+  }
+  async unpin(cid) {
+    const response = await fetch(`${this.baseUrl}/pin/rm?arg=${cid}`, {
+      method: "POST",
+      headers: {
+        Authorization: this.getAuthHeader()
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Infura unpin failed: ${error}`);
+    }
+  }
+  async getPinStatus(cid) {
+    const response = await fetch(`${this.baseUrl}/pin/ls?arg=${cid}`, {
+      headers: {
+        Authorization: this.getAuthHeader()
+      }
+    });
+    if (!response.ok) {
+      return "unpinned";
+    }
+    const data = await response.json();
+    return data.Keys && data.Keys[cid] ? "pinned" : "unpinned";
+  }
+  async listPins() {
+    const response = await fetch(`${this.baseUrl}/pin/ls`, {
+      headers: {
+        Authorization: this.getAuthHeader()
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to list pins");
+    }
+    const data = await response.json();
+    return Object.entries(data.Keys || {}).map(([cid, info]) => ({
+      cid,
+      name: cid,
+      size: 0,
+      // Infura doesn't provide size in pin list
+      status: "pinned"
+    }));
+  }
+  async verifyCID(cid) {
+    try {
+      const response = await fetch(`${this.baseUrl}/cat?arg=${cid}`, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader()
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/storage/IPFSService.ts
+var IPFSService = class {
+  constructor(options) {
+    this.fallbackProviders = [];
+    this.defaultGateway = "https://ipfs.io/ipfs";
+    this.cdnGateway = "https://cloudflare-ipfs.com/ipfs";
+    this.options = {
+      ...options,
+      fallbackProviders: options.fallbackProviders || [],
+      enableCDN: options.enableCDN ?? true,
+      maxFileSize: options.maxFileSize || 100 * 1024 * 1024,
+      // 100MB
+      chunkSize: options.chunkSize || 5 * 1024 * 1024,
+      // 5MB
+      maxRetries: options.maxRetries || 3,
+      retryDelay: options.retryDelay || 1e3,
+      gatewayUrl: options.gatewayUrl || this.defaultGateway,
+      apiSecret: options.apiSecret
+    };
+    this.primaryProvider = this.createProvider(
+      this.options.provider,
+      this.options.apiKey,
+      this.options.apiSecret
+    );
+    for (const fallback of this.options.fallbackProviders) {
+      const provider = this.createProvider(fallback.provider, fallback.apiKey, fallback.apiSecret);
+      this.fallbackProviders.push(provider);
+    }
+  }
+  /**
+   * Create provider instance
+   */
+  createProvider(type, apiKey, apiSecret) {
+    switch (type) {
+      case "pinata":
+        return new PinataProvider(apiKey, apiSecret);
+      case "nft.storage":
+        return new NFTStorageProvider(apiKey);
+      case "infura":
+        return new InfuraProvider(apiKey, apiSecret);
+      default:
+        throw new Error(`Unknown IPFS provider: ${type}`);
+    }
+  }
+  /**
+   * Upload files to IPFS
+   *
+   * Returns CID and gateway URLs. Automatically retries on failure and falls back
+   * to backup providers if primary fails.
+   *
+   * @param options Upload options
+   * @returns Upload result with CID and URLs
+   * @throws {FileSizeExceededError} If file size exceeds maximum
+   * @throws {IPFSUploadError} If upload fails on all providers
+   */
+  async upload(options) {
+    const startTime = Date.now();
+    const totalSize = options.files.reduce((sum, file) => {
+      const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
+      return sum + size;
+    }, 0);
+    if (totalSize > this.options.maxFileSize) {
+      throw new FileSizeExceededError(totalSize, this.options.maxFileSize);
+    }
+    const needsChunking = totalSize > this.options.chunkSize;
+    try {
+      const result = await this.uploadWithRetry(
+        this.primaryProvider,
+        this.options.provider,
+        options,
+        needsChunking
+      );
+      return this.buildUploadResult(result.cid, result.size, startTime, options.pin ?? true);
+    } catch (primaryError) {
+      console.warn(`Primary provider ${this.options.provider} failed:`, primaryError);
+      for (let i = 0; i < this.fallbackProviders.length; i++) {
+        const provider = this.fallbackProviders[i];
+        const providerType = this.options.fallbackProviders[i].provider;
+        try {
+          const result = await this.uploadWithRetry(provider, providerType, options, needsChunking);
+          return this.buildUploadResult(result.cid, result.size, startTime, options.pin ?? true);
+        } catch (error) {
+          console.warn(`Fallback provider ${providerType} failed:`, error);
+          continue;
+        }
+      }
+      throw new IPFSUploadError(
+        "Upload failed on all providers",
+        this.options.provider,
+        primaryError
+      );
+    }
+  }
+  /**
+   * Upload with retry logic
+   */
+  async uploadWithRetry(provider, providerType, options, needsChunking) {
+    let lastError;
+    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
+      try {
+        if (needsChunking) {
+          return await this.uploadChunked(provider, options);
+        } else {
+          if (options.onProgress) {
+            const totalSize = options.files.reduce((sum, file) => {
+              const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
+              return sum + size;
+            }, 0);
+            let uploadedBytes = 0;
+            for (const file of options.files) {
+              const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
+              uploadedBytes += size;
+              options.onProgress({
+                uploadedBytes,
+                totalBytes: totalSize,
+                percentage: uploadedBytes / totalSize * 100,
+                currentFile: file.path
+              });
+            }
+          }
+          return await provider.upload(options.files, options);
+        }
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.options.maxRetries - 1) {
+          const delay = this.options.retryDelay * Math.pow(2, attempt);
+          await this.delay(delay);
+        }
+      }
+    }
+    throw new IPFSUploadError(
+      `Upload failed after ${this.options.maxRetries} attempts`,
+      providerType,
+      lastError
+    );
+  }
+  /**
+   * Upload large files in chunks
+   *
+   * Breaks large files into smaller chunks, uploads them separately,
+   * and combines them into a single IPFS directory.
+   */
+  async uploadChunked(provider, options) {
+    const chunks = [];
+    let totalSize = 0;
+    let uploadedBytes = 0;
+    for (const file of options.files) {
+      const content = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content : Buffer.from(file.content);
+      const fileSize = content.length;
+      totalSize += fileSize;
+      if (fileSize > this.options.chunkSize) {
+        const numChunks = Math.ceil(fileSize / this.options.chunkSize);
+        for (let i = 0; i < numChunks; i++) {
+          const start = i * this.options.chunkSize;
+          const end = Math.min(start + this.options.chunkSize, fileSize);
+          const chunk = content.slice(start, end);
+          chunks.push({
+            path: `${file.path}.chunk${i}`,
+            content: chunk
+          });
+          uploadedBytes += chunk.length;
+          if (options.onProgress) {
+            options.onProgress({
+              uploadedBytes,
+              totalBytes: totalSize,
+              percentage: uploadedBytes / totalSize * 100,
+              currentFile: file.path
+            });
+          }
+        }
+      } else {
+        chunks.push(file);
+        uploadedBytes += fileSize;
+        if (options.onProgress) {
+          options.onProgress({
+            uploadedBytes,
+            totalBytes: totalSize,
+            percentage: uploadedBytes / totalSize * 100,
+            currentFile: file.path
+          });
+        }
+      }
+    }
+    return await provider.upload(chunks, options);
+  }
+  /**
+   * Build upload result
+   */
+  buildUploadResult(cid, size, startTime, pinned) {
+    const gatewayUrl = `${this.options.gatewayUrl}/${cid}`;
+    const cdnUrl = this.options.enableCDN ? `${this.cdnGateway}/${cid}` : void 0;
+    return {
+      cid,
+      uri: `ipfs://${cid}`,
+      gatewayUrl,
+      cdnUrl,
+      pinned,
+      size,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Pin existing CID to IPFS
+   *
+   * @param cid IPFS CID to pin
+   * @param name Optional name for the pin
+   * @throws {IPFSPinError} If pin operation fails
+   */
+  async pin(cid, name) {
+    try {
+      await this.primaryProvider.pin(cid, name);
+    } catch (error) {
+      throw new IPFSPinError(`Failed to pin CID ${cid}`, cid, error);
+    }
+  }
+  /**
+   * Unpin CID from IPFS
+   *
+   * @param cid IPFS CID to unpin
+   * @throws {IPFSPinError} If unpin operation fails
+   */
+  async unpin(cid) {
+    try {
+      await this.primaryProvider.unpin(cid);
+    } catch (error) {
+      throw new IPFSPinError(`Failed to unpin CID ${cid}`, cid, error);
+    }
+  }
+  /**
+   * Get pin status for CID
+   *
+   * @param cid IPFS CID to check
+   * @returns Pin status ('pinned', 'pinning', or 'unpinned')
+   */
+  async getPinStatus(cid) {
+    return await this.primaryProvider.getPinStatus(cid);
+  }
+  /**
+   * Verify CID exists and is accessible
+   *
+   * @param cid IPFS CID to verify
+   * @returns True if CID is accessible
+   */
+  async verifyCID(cid) {
+    return await this.primaryProvider.verifyCID(cid);
+  }
+  /**
+   * Get file from IPFS
+   *
+   * @param cid IPFS CID
+   * @param path Optional path within directory
+   * @returns File content as Uint8Array
+   */
+  async get(cid, path) {
+    const url = path ? `${this.options.gatewayUrl}/${cid}/${path}` : `${this.options.gatewayUrl}/${cid}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch CID ${cid}: ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  /**
+   * List all pins for account
+   *
+   * @returns Array of pin information
+   */
+  async listPins() {
+    return await this.primaryProvider.listPins();
+  }
+  /**
+   * Delay helper for retry logic
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get CDN URL for CID
+   *
+   * @param cid IPFS CID
+   * @returns CDN URL if enabled, otherwise gateway URL
+   */
+  getCDNUrl(cid) {
+    return this.options.enableCDN ? `${this.cdnGateway}/${cid}` : `${this.options.gatewayUrl}/${cid}`;
+  }
+  /**
+   * Get gateway URL for CID
+   *
+   * @param cid IPFS CID
+   * @returns Gateway URL
+   */
+  getGatewayUrl(cid) {
+    return `${this.options.gatewayUrl}/${cid}`;
+  }
+  /**
+   * Get IPFS URI for CID
+   *
+   * @param cid IPFS CID
+   * @returns IPFS URI (ipfs://...)
+   */
+  getIPFSUri(cid) {
+    return `ipfs://${cid}`;
+  }
+};
+
+export { FileSizeExceededError, IPFSPinError, IPFSService, IPFSUploadError, InfuraProvider, NFTStorageProvider, PinataProvider };
+//# sourceMappingURL=chunk-WRWEX5ZF.js.map
+//# sourceMappingURL=chunk-WRWEX5ZF.js.map