@net-protocol/storage 0.1.5 → 0.1.7

package/README.md

@@ -19,7 +19,7 @@ Net Storage supports three storage patterns for different file sizes:
 
 ### Regular Storage
 
-**Best for**: Small data (< 20KB)  
+**Best for**: Small data (≤ 20KB)  
 **How it works**: Stores data directly as Net messages  
 **Use cases**: User settings, configuration, small metadata
 
@@ -27,12 +27,13 @@ Net Storage supports three storage patterns for different file sizes:
 
 **Best for**: Medium files (20KB-80KB)  
 **How it works**: Compresses data (gzip) and splits into 20KB chunks  
-**Use cases**: Images, documents, medium-sized data
+**Use cases**: Images, documents, medium-sized data  
+**Note**: ChunkedStorage is typically used internally by XML Storage. For direct usage, see `StorageClient.prepareChunkedPut()`.
 
 ### XML Storage
 
-**Best for**: Large files (multi-MB)  
-**How it works**: Splits large files into 80KB pieces, stores each using ChunkedStorage, maintains references as XML metadata  
+**Best for**: Large files (> 20KB) or files containing XML references  
+**How it works**: Splits large files into 80KB pieces, stores each using ChunkedStorage (compressed and chunked into 20KB pieces), maintains references as XML metadata  
 **Use cases**: Videos, large images, datasets, any large file
 
 ## What can you do with this package?

package/dist/index.js

@@ -1088,17 +1088,37 @@ function useStorageTotalWrites({
 var MAX_XML_DEPTH = 3;
 var CONCURRENT_XML_FETCHES = 3;
 function assembleXmlData(metadata, chunks, references) {
+  const tagPositions = [];
+  for (let i = 0; i < references.length; i++) {
+    const ref = references[i];
+    const chunkData2 = chunks[i];
+    if (!chunkData2) continue;
+    const indexAttr = ref.index !== void 0 ? ` i="${ref.index}"` : "";
+    const operatorAttr = ref.operator ? ` o="${ref.operator}"` : "";
+    const sourceAttr = ref.source ? ` s="${ref.source}"` : "";
+    const xmlTag = `<net k="${ref.hash}" v="${ref.version}"${indexAttr}${operatorAttr}${sourceAttr} />`;
+    const tagIndex = metadata.indexOf(xmlTag);
+    if (tagIndex === -1) {
+      continue;
+    }
+    tagPositions.push({
+      ref,
+      chunk: chunkData2,
+      start: tagIndex,
+      end: tagIndex + xmlTag.length,
+      tag: xmlTag
+    });
+  }
+  tagPositions.sort((a, b) => b.start - a.start);
   let result = metadata;
-  references.forEach((ref, index) => {
-    const chunkData2 = chunks[index];
-    if (chunkData2) {
-      const indexAttr = ref.index !== void 0 ? ` i="${ref.index}"` : "";
-      const operatorAttr = ref.operator ? ` o="${ref.operator}"` : "";
-      const sourceAttr = ref.source ? ` s="${ref.source}"` : "";
-      const xmlTag = `<net k="${ref.hash}" v="${ref.version}"${indexAttr}${operatorAttr}${sourceAttr} />`;
-      result = result.replace(xmlTag, chunkData2);
+  for (let i = 0; i < tagPositions.length; i++) {
+    const { ref, chunk, start, end } = tagPositions[i];
+    try {
+      result = result.substring(0, start) + chunk + result.substring(end);
+    } catch (error) {
+      throw error;
     }
-  });
+  }
   return result;
 }
 async function fetchFromDirectStorage(reference, operator, client) {
@@ -1929,9 +1949,7 @@ var StorageClient = class {
     const transactionConfigs = [];
     for (const xmlChunk of params.xmlChunks) {
       const chunks = chunkDataForStorage(xmlChunk);
-      const chunkedHash = core.keccak256HashString(
-        xmlChunk + params.operatorAddress
-      );
+      const chunkedHash = core.keccak256HashString(xmlChunk);
       chunkedStorageHashes.push(chunkedHash);
       const config = this.prepareChunkedPut({
         key: chunkedHash,
@@ -2141,9 +2159,22 @@ function detectFileTypeFromBase64(base64Data) {
       } catch {
       }
     }
-    if (base64Data.startsWith("SUQz") || base64Data.startsWith("/9s=")) {
+    if (base64Data.startsWith("SUQz")) {
       return "audio/mpeg";
     }
+    if (base64Data.length >= 4) {
+      try {
+        const decoded = atob(base64Data.substring(0, 4));
+        const bytes = new Uint8Array(decoded.length);
+        for (let i = 0; i < decoded.length; i++) {
+          bytes[i] = decoded.charCodeAt(i);
+        }
+        if (bytes[0] === 255 && (bytes[1] & 240) === 240) {
+          return "audio/mpeg";
+        }
+      } catch {
+      }
+    }
     if (base64Data.length > 20) {
       try {
         const decoded = atob(base64Data.substring(0, Math.min(50, base64Data.length)));