hippius 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

hippius_sdk/ipfs.py

@@ -1,7 +1,7 @@
 """
 IPFS operations for the Hippius SDK.
 """
-
+import asyncio
 import hashlib
 import json
 import os
@@ -10,7 +10,7 @@ import shutil
 import tempfile
 import time
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import httpx
 import requests
@@ -37,6 +37,12 @@ try:
 except ImportError:
     ERASURE_CODING_AVAILABLE = False
 
+# Configuration constants
+PARALLEL_EC_CHUNKS = 20  # Maximum number of concurrent chunk downloads
+PARALLEL_ORIGINAL_CHUNKS = (
+    15  # Maximum number of original chunks to process in parallel
+)
+
 
 class IPFSClient:
     """Client for interacting with IPFS."""
@@ -60,7 +66,7 @@ class IPFSClient:
         """
         # Load configuration values if not explicitly provided
         if gateway is None:
-            gateway = get_config_value("ipfs", "gateway", "https://ipfs.io")
+            gateway = get_config_value("ipfs", "gateway", "https://get.hippius.network")
 
         if api_url is None:
             api_url = get_config_value(
@@ -78,11 +84,12 @@ class IPFSClient:
         self.base_url = api_url
 
         try:
-            self.client = AsyncIPFSClient(api_url)
+            self.client = AsyncIPFSClient(api_url=api_url, gateway=self.gateway)
         except httpx.ConnectError as e:
-            print(f"Warning: Could not connect to IPFS node at {api_url}: {e}")
-            # Try to connect to local IPFS daemon as fallback
-            self.client = AsyncIPFSClient()
+            print(
+                f"Warning: Falling back to local IPFS daemon, but still using gateway={self.gateway}"
+            )
+            self.client = AsyncIPFSClient(gateway=self.gateway)
 
         self._initialize_encryption(encrypt_by_default, encryption_key)
 
@@ -477,8 +484,6 @@ class IPFSClient:
 
             # Download the file with retry logic
             retries = 0
-            last_error = None
-
             while retries < max_retries:
                 try:
                     # Download the file
@@ -499,7 +504,6 @@ class IPFSClient:
 
                 except (requests.exceptions.RequestException, IOError) as e:
                     # Save the error and retry
-                    last_error = e
                     retries += 1
 
                     if retries < max_retries:
@@ -736,6 +740,7 @@ class IPFSClient:
         encrypt: Optional[bool] = None,
         max_retries: int = 3,
         verbose: bool = True,
+        progress_callback: Optional[Callable[[str, int, int], None]] = None,
     ) -> Dict[str, Any]:
         """
         Split a file using erasure coding, then upload the chunks to IPFS.
@@ -753,6 +758,8 @@ class IPFSClient:
             encrypt: Whether to encrypt the file before encoding (defaults to self.encrypt_by_default)
             max_retries: Maximum number of retry attempts for IPFS uploads
             verbose: Whether to print progress information
+            progress_callback: Optional callback function for progress updates
+                            Function receives (stage_name, current, total)
 
         Returns:
             dict: Metadata including the original file info and chunk information
@@ -934,14 +941,19 @@ class IPFSClient:
 
         # Step 4: Upload all chunks to IPFS
         if verbose:
-            print(f"Uploading {len(chunks) * m} erasure-coded chunks to IPFS...")
+            print(
+                f"Uploading {len(chunks) * m} erasure-coded chunks to IPFS in parallel..."
+            )
 
         chunk_uploads = 0
         chunk_data = []
+        batch_size = 20  # Number of concurrent uploads
 
         # Create a temporary directory for the chunks
         with tempfile.TemporaryDirectory() as temp_dir:
-            # Write and upload each encoded chunk
+            # Prepare all chunks for upload
+            all_chunk_info = []
+
             for original_idx, encoded_chunks in enumerate(all_encoded_chunks):
                 for share_idx, share_data in enumerate(encoded_chunks):
                     # Create a name for this chunk that includes needed info
@@ -952,29 +964,64 @@ class IPFSClient:
                     with open(chunk_path, "wb") as f:
                         f.write(share_data)
 
-                    # Upload the chunk to IPFS
-                    try:
-                        chunk_cid = await self.upload_file(
-                            chunk_path, max_retries=max_retries
-                        )
-
-                        # Store info about this chunk
-                        chunk_info = {
+                    # Store info for async upload
+                    all_chunk_info.append(
+                        {
                             "name": chunk_name,
-                            "cid": chunk_cid,
+                            "path": chunk_path,
                             "original_chunk": original_idx,
                             "share_idx": share_idx,
                             "size": len(share_data),
                         }
-                        chunk_data.append(chunk_info)
+                    )
+
+            # Create a semaphore to limit concurrent uploads
+            semaphore = asyncio.Semaphore(batch_size)
+
+            # Track total uploads for progress reporting
+            total_chunks = len(all_chunk_info)
 
+            # Initialize progress tracking if callback provided
+            if progress_callback:
+                progress_callback("upload", 0, total_chunks)
+
+            if verbose:
+                print(f"Uploading {total_chunks} erasure-coded chunks to IPFS...")
+
+            # Define upload task for a single chunk
+            async def upload_chunk(chunk_info):
+                nonlocal chunk_uploads
+
+                async with semaphore:
+                    try:
+                        chunk_cid = await self.upload_file(
+                            chunk_info["path"], max_retries=max_retries
+                        )
+                        chunk_info["cid"] = chunk_cid
                         chunk_uploads += 1
+
+                        # Update progress through callback
+                        if progress_callback:
+                            progress_callback("upload", chunk_uploads, total_chunks)
+
                         if verbose and chunk_uploads % 10 == 0:
+                            print(f"  Uploaded {chunk_uploads}/{total_chunks} chunks")
+                        return chunk_info
+                    except Exception as e:
+                        if verbose:
                             print(
-                                f"  Uploaded {chunk_uploads}/{len(chunks) * m} chunks"
+                                f"Error uploading chunk {chunk_info['name']}: {str(e)}"
                             )
-                    except Exception as e:
-                        print(f"Error uploading chunk {chunk_name}: {str(e)}")
+                        return None
+
+            # Create tasks for all chunk uploads
+            upload_tasks = [upload_chunk(chunk_info) for chunk_info in all_chunk_info]
+
+            # Wait for all uploads to complete
+            completed_uploads = await asyncio.gather(*upload_tasks)
+
+            # Filter out failed uploads
+            chunk_data = [upload for upload in completed_uploads if upload is not None]
 
             # Add all chunk info to metadata
             metadata["chunks"] = chunk_data
@@ -1012,7 +1059,7 @@ class IPFSClient:
         temp_dir: str = None,
         max_retries: int = 3,
         verbose: bool = True,
-    ) -> str:
+    ) -> Dict:
         """
         Reconstruct a file from erasure-coded chunks using its metadata.
 
@@ -1024,7 +1071,7 @@ class IPFSClient:
             verbose: Whether to print progress information
 
         Returns:
-            str: Path to the reconstructed file
+            Dict: containing file reconstruction info.
 
         Raises:
             ValueError: If reconstruction fails
@@ -1082,6 +1129,9 @@ class IPFSClient:
                 )
                 if is_encrypted:
                     print("Encrypted: Yes")
+                print(
+                    f"Using parallel download with max {PARALLEL_ORIGINAL_CHUNKS} original chunks and {PARALLEL_EC_CHUNKS} chunk downloads concurrently"
+                )
 
             # Step 3: Group chunks by their original chunk index
             chunks_by_original = {}
@@ -1091,136 +1141,157 @@ class IPFSClient:
                     chunks_by_original[orig_idx] = []
                 chunks_by_original[orig_idx].append(chunk)
 
-            # Step 4: For each original chunk, download at least k shares
+            # Step 4: Process all original chunks in parallel
             if verbose:
                 total_original_chunks = len(chunks_by_original)
-                total_chunks_to_download = total_original_chunks * k
+                total_chunks_needed = total_original_chunks * k
                 print(
-                    f"Downloading and reconstructing {total_chunks_to_download} chunks..."
+                    f"Downloading and reconstructing {total_chunks_needed} chunks in parallel..."
                 )
 
-            reconstructed_chunks = []
-            chunks_downloaded = 0
-            chunks_failed = 0
-
-            for orig_idx in sorted(chunks_by_original.keys()):
-                available_chunks = chunks_by_original[orig_idx]
-
-                if len(available_chunks) < k:
-                    raise ValueError(
-                        f"Not enough chunks available for original chunk {orig_idx}. "
-                        f"Need {k}, but only have {len(available_chunks)}."
-                    )
+            # Create semaphores to limit concurrency
+            encoded_chunks_semaphore = asyncio.Semaphore(PARALLEL_EC_CHUNKS)
+            original_chunks_semaphore = asyncio.Semaphore(PARALLEL_ORIGINAL_CHUNKS)
+
+            # Process a single original chunk and its required downloads
+            async def process_original_chunk(orig_idx, available_chunks):
+                # Limit number of original chunks processing at once
+                async with original_chunks_semaphore:
+                    if verbose:
+                        print(f"Processing original chunk {orig_idx}...")
+
+                    if len(available_chunks) < k:
+                        raise ValueError(
+                            f"Not enough chunks available for original chunk {orig_idx}. "
+                            f"Need {k}, but only have {len(available_chunks)}."
+                        )
 
-                # Try to download all available chunks, but we only need k successful ones
-                downloaded_shares = []
-                share_indexes = []
-                chunks_to_try = available_chunks.copy()
+                    # Try slightly more than k chunks (k+2) to handle some failures
+                    num_to_try = min(k + 2, len(available_chunks))
+                    chunks_to_try = random.sample(available_chunks, num_to_try)
 
-                # Shuffle to get a better variety of chunks
-                random.shuffle(chunks_to_try)
+                    # Track downloaded chunks
+                    download_tasks = []
 
-                for chunk in chunks_to_try:
-                    # Break if we already have k chunks
-                    if len(downloaded_shares) >= k:
-                        break
+                    # Start parallel downloads for chunks
+                    for chunk in chunks_to_try:
+                        chunk_path = os.path.join(temp_dir, f"{chunk['name']}")
 
-                    chunk_path = os.path.join(temp_dir, chunk["name"])
-                    try:
-                        # Extract the CID string from the chunk's cid dictionary
+                        # Extract CID
                         chunk_cid = (
                             chunk["cid"]["cid"]
                             if isinstance(chunk["cid"], dict) and "cid" in chunk["cid"]
                             else chunk["cid"]
                         )
-                        await self.download_file(
-                            chunk_cid, chunk_path, max_retries=max_retries
-                        )
-                        chunks_downloaded += 1
 
-                        # Read the chunk data
-                        with open(chunk_path, "rb") as f:
-                            share_data = f.read()
-
-                        downloaded_shares.append(share_data)
-                        share_indexes.append(chunk["share_idx"])
-
-                    except Exception as e:
-                        if verbose:
-                            print(f"Error downloading chunk {chunk['name']}: {str(e)}")
-                        chunks_failed += 1
-                        # Continue to the next chunk
+                        # Create download task
+                        async def download_chunk(cid, path, chunk_info):
+                            async with encoded_chunks_semaphore:
+                                try:
+                                    await self.download_file(
+                                        cid, path, max_retries=max_retries
+                                    )
+
+                                    # Read chunk data
+                                    with open(path, "rb") as f:
+                                        share_data = f.read()
+
+                                    return {
+                                        "success": True,
+                                        "data": share_data,
+                                        "share_idx": chunk_info["share_idx"],
+                                        "name": chunk_info["name"],
+                                    }
+                                except Exception as e:
+                                    if verbose:
+                                        print(
+                                            f"Error downloading chunk {chunk_info['name']}: {str(e)}"
+                                        )
+                                    return {
+                                        "success": False,
+                                        "error": str(e),
+                                        "name": chunk_info["name"],
+                                    }
+
+                        # Create task
+                        task = asyncio.create_task(
+                            download_chunk(chunk_cid, chunk_path, chunk)
+                        )
+                        download_tasks.append(task)
+
+                    # Process downloads as they complete
+                    downloaded_shares = []
+                    share_indexes = []
+
+                    for done_task in asyncio.as_completed(download_tasks):
+                        result = await done_task
+
+                        if result["success"]:
+                            downloaded_shares.append(result["data"])
+                            share_indexes.append(result["share_idx"])
+
+                            # Once we have k chunks, cancel remaining downloads
+                            if len(downloaded_shares) >= k:
+                                for task in download_tasks:
+                                    if not task.done():
+                                        task.cancel()
+                                break
+
+                    # Check if we have enough chunks
+                    if len(downloaded_shares) < k:
+                        raise ValueError(
+                            f"Failed to download enough chunks for original chunk {orig_idx}. "
+                            f"Need {k}, but only downloaded {len(downloaded_shares)}."
+                        )
 
-                # If we don't have enough chunks, fail
-                if len(downloaded_shares) < k:
-                    raise ValueError(
-                        f"Failed to download enough chunks for original chunk {orig_idx}. "
-                        f"Need {k}, but only downloaded {len(downloaded_shares)}."
+                    # Reconstruct this chunk
+                    decoder = zfec.Decoder(k, m)
+                    reconstructed_data = decoder.decode(
+                        downloaded_shares, share_indexes
                     )
 
-                # Reconstruct this chunk
-                decoder = zfec.Decoder(k, m)
-                reconstructed_data = decoder.decode(downloaded_shares, share_indexes)
+                    if not isinstance(reconstructed_data, list):
+                        raise TypeError(
+                            f"Unexpected type from decoder: {type(reconstructed_data)}. Expected list of bytes."
+                        )
 
-                if not isinstance(reconstructed_data, list):
-                    # Handle unexpected output type
-                    raise TypeError(
-                        f"Unexpected type from decoder: {type(reconstructed_data)}. Expected list of bytes."
-                    )
+                    # Calculate the actual size of this original chunk
+                    is_last_chunk = orig_idx == max(chunks_by_original.keys())
+                    original_chunk_size = total_original_size - orig_idx * chunk_size
+                    if not is_last_chunk:
+                        original_chunk_size = min(chunk_size, original_chunk_size)
+
+                    # Recombine the sub-blocks
+                    reconstructed_chunk = b""
+                    total_bytes = 0
+                    for sub_block in reconstructed_data:
+                        bytes_to_take = min(
+                            len(sub_block), original_chunk_size - total_bytes
+                        )
+                        if bytes_to_take <= 0:
+                            break
 
-                # Calculate the actual size of this original chunk
-                # For all chunks except possibly the last one, it should be chunk_size
-                is_last_chunk = orig_idx == max(chunks_by_original.keys())
-                original_chunk_size = total_original_size - orig_idx * chunk_size
-                if not is_last_chunk:
-                    original_chunk_size = min(chunk_size, original_chunk_size)
-
-                # Recombine the sub-blocks, respecting the original chunk size
-                reconstructed_chunk = b""
-                total_bytes = 0
-                for sub_block in reconstructed_data:
-                    # Calculate how many bytes we should take from this sub-block
-                    bytes_to_take = min(
-                        len(sub_block), original_chunk_size - total_bytes
-                    )
-                    if bytes_to_take <= 0:
-                        break
+                        reconstructed_chunk += sub_block[:bytes_to_take]
+                        total_bytes += bytes_to_take
 
-                    reconstructed_chunk += sub_block[:bytes_to_take]
-                    total_bytes += bytes_to_take
+                    return reconstructed_chunk
 
-                reconstructed_chunks.append(reconstructed_chunk)
+            # Create tasks for all original chunks and process them in parallel
+            chunk_tasks = []
+            for orig_idx in sorted(chunks_by_original.keys()):
+                chunk_tasks.append(
+                    process_original_chunk(orig_idx, chunks_by_original[orig_idx])
+                )
 
-                # Add debugging information if verbose
-                if verbose:
-                    progress_pct = (orig_idx + 1) / total_original_chunks * 100
-                    print(
-                        f"  Progress: {orig_idx + 1}/{total_original_chunks} chunks ({progress_pct:.1f}%)"
-                    )
-                    if (
-                        orig_idx == 0 or is_last_chunk
-                    ):  # Only show debug for first and last chunks to avoid spam
-                        print(f"  Debug info for chunk {orig_idx}:")
-                        print(f"    Original chunk size: {original_chunk_size} bytes")
-                        print(
-                            f"    Reconstructed chunk size: {len(reconstructed_chunk)} bytes"
-                        )
-                        print(f"    Share indexes used: {share_indexes}")
-                        print(f"    Sub-blocks received: {len(reconstructed_data)}")
+            # Wait for all chunks to be reconstructed
+            reconstructed_chunks = await asyncio.gather(*chunk_tasks)
 
             if verbose:
                 download_time = time.time() - start_time
-                print(
-                    f"Downloaded {chunks_downloaded} chunks in {download_time:.2f} seconds"
-                )
-                if chunks_failed > 0:
-                    print(
-                        f"Failed to download {chunks_failed} chunks (not needed for reconstruction)"
-                    )
+                print(f"Chunk reconstruction completed in {download_time:.2f} seconds")
 
             # Step 5: Combine the reconstructed chunks into a file
-            if verbose:
-                print("Combining reconstructed chunks...")
+            print("Combining reconstructed chunks...")
 
             # Process chunks to remove padding correctly
             processed_chunks = []
@@ -1293,7 +1364,10 @@ class IPFSClient:
                 print(f"Reconstruction complete in {total_time:.2f} seconds!")
                 print(f"File saved to: {output_file}")
 
-            return output_file
+            return {
+                "output_path": output_file,
+                "size_bytes": size_processed,
+            }
 
         finally:
             # Clean up temporary directory if we created it
@@ -1311,6 +1385,7 @@ class IPFSClient:
         substrate_client=None,
         max_retries: int = 3,
         verbose: bool = True,
+        progress_callback: Optional[Callable[[str, int, int], None]] = None,
     ) -> Dict[str, Any]:
         """
         Erasure code a file, upload the chunks to IPFS, and store in the Hippius marketplace.
@@ -1327,6 +1402,8 @@ class IPFSClient:
             substrate_client: SubstrateClient to use (or None to create one)
             max_retries: Maximum number of retry attempts
             verbose: Whether to print progress information
+            progress_callback: Optional callback function for progress updates
+                            Function receives (stage_name, current, total)
 
         Returns:
             dict: Result including metadata CID and transaction hash
@@ -1344,6 +1421,7 @@ class IPFSClient:
             encrypt=encrypt,
             max_retries=max_retries,
             verbose=verbose,
+            progress_callback=progress_callback,
         )
 
         # Step 2: Create substrate client if we need it
@@ -1418,3 +1496,335 @@ class IPFSClient:
             print(f"Error storing files in marketplace: {str(e)}")
             # Return the metadata even if storage fails
             return {"metadata": metadata, "metadata_cid": metadata_cid, "error": str(e)}
+
+    async def delete_file(
+        self, cid: str, cancel_from_blockchain: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Delete a file from IPFS and optionally cancel its storage on the blockchain.
+
+        Args:
+            cid: Content Identifier (CID) of the file to delete
+            cancel_from_blockchain: Whether to also cancel the storage request from the blockchain
+
+        Returns:
+            Dict containing the result of the operation
+        """
+        result = {
+            "cid": cid,
+            "unpin_result": None,
+            "blockchain_result": None,
+            "timing": {
+                "start_time": time.time(),
+                "end_time": None,
+                "duration_seconds": None,
+            },
+        }
+
+        # First, unpin from IPFS
+        try:
+            print(f"Unpinning file from IPFS: {cid}")
+            try:
+                # Try to check if file exists in IPFS before unpinning
+                await self.exists(cid)
+            except Exception as exists_e:
+                print(f"ERROR: Error checking file existence: {exists_e}")
+
+            unpin_result = await self.client.unpin(cid)
+            result["unpin_result"] = unpin_result
+            print("Successfully unpinned from IPFS")
+        except Exception as e:
+            print(f"Warning: Failed to unpin file from IPFS: {e}")
+            raise
+
+        # Then, if requested, cancel from blockchain
+        if cancel_from_blockchain:
+            try:
+                # Create a substrate client
+                print(f"DEBUG: Creating SubstrateClient for blockchain cancellation...")
+                substrate_client = SubstrateClient()
+                print(
+                    f"DEBUG: Substrate client created with URL: {substrate_client.url}"
+                )
+                print(f"DEBUG: Calling cancel_storage_request with CID: {cid}")
+
+                tx_hash = await substrate_client.cancel_storage_request(cid)
+                print(f"DEBUG: Received transaction hash: {tx_hash}")
+
+                # Check the return value - special cases for when blockchain cancellation isn't available
+                if tx_hash == "no-blockchain-cancellation-available":
+                    print(
+                        "Blockchain cancellation not available, but IPFS unpinning was successful"
+                    )
+                    result["blockchain_result"] = {
+                        "status": "not_available",
+                        "message": "Blockchain cancellation not available, but IPFS unpinning was successful",
+                    }
+                elif tx_hash.startswith("ipfs-unpinned-only"):
+                    error_msg = tx_hash.replace("ipfs-unpinned-only-", "")
+                    print(
+                        f"IPFS unpinning successful, but blockchain cancellation failed: {error_msg}"
+                    )
+                    result["blockchain_result"] = {
+                        "status": "failed",
+                        "error": error_msg,
+                        "message": "IPFS unpinning successful, but blockchain cancellation failed",
+                    }
+                else:
+                    # Standard successful transaction
+                    result["blockchain_result"] = {
+                        "transaction_hash": tx_hash,
+                        "status": "success",
+                    }
+                    print(f"Successfully canceled storage request from blockchain")
+                    print(
+                        f"DEBUG: Blockchain cancellation succeeded with transaction hash: {tx_hash}"
+                    )
+            except Exception as e:
+                print(f"Warning: Failed to cancel storage from blockchain: {e}")
+                print(
+                    f"DEBUG: Blockchain cancellation exception: {type(e).__name__}: {str(e)}"
+                )
+                if hasattr(e, "__dict__"):
+                    print(f"DEBUG: Exception attributes: {e.__dict__}")
+                result["blockchain_error"] = str(e)
+
+        # Calculate timing
+        result["timing"]["end_time"] = time.time()
+        result["timing"]["duration_seconds"] = (
+            result["timing"]["end_time"] - result["timing"]["start_time"]
+        )
+
+        return result
+
+    async def delete_ec_file(
+        self,
+        metadata_cid: str,
+        cancel_from_blockchain: bool = True,
+        parallel_limit: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        Delete an erasure-coded file, including all its chunks in parallel.
+
+        Args:
+            metadata_cid: CID of the metadata file for the erasure-coded file
+            cancel_from_blockchain: Whether to cancel storage from blockchain
+            parallel_limit: Maximum number of concurrent deletion operations
+
+        Returns:
+            Dict containing the result of the operation
+        """
+        result = {
+            "metadata_cid": metadata_cid,
+            "deleted_chunks": [],
+            "failed_chunks": [],
+            "blockchain_result": None,
+            "timing": {
+                "start_time": time.time(),
+                "end_time": None,
+                "duration_seconds": None,
+            },
+        }
+
+        # Track deletions for reporting
+        deleted_chunks_lock = asyncio.Lock()
+        failed_chunks_lock = asyncio.Lock()
+
+        # First, get the metadata to find all chunks
+        try:
+            print(f"Downloading metadata file (CID: {metadata_cid})...")
+            start_time = time.time()
+            metadata_content = await self.client.cat(metadata_cid)
+            metadata = json.loads(metadata_content.decode("utf-8"))
+            metadata_download_time = time.time() - start_time
+
+            print(f"Metadata downloaded in {metadata_download_time:.2f} seconds")
+
+            # Extract chunk CIDs
+            chunks = []
+            total_chunks = 0
+
+            for chunk_data in metadata.get("chunks", []):
+                for ec_chunk in chunk_data.get("ec_chunks", []):
+                    chunk_cid = ec_chunk.get("cid")
+                    if chunk_cid:
+                        chunks.append(chunk_cid)
+                        total_chunks += 1
+
+            print(f"Found {total_chunks} chunks to delete")
+
+            # Create a semaphore to limit concurrent operations
+            sem = asyncio.Semaphore(parallel_limit)
+
+            # Define the chunk deletion function
+            async def delete_chunk(chunk_cid):
+                async with sem:
+                    try:
+                        print(f"Unpinning chunk: {chunk_cid}")
+                        await self.client.unpin(chunk_cid)
+
+                        # Record success
+                        async with deleted_chunks_lock:
+                            result["deleted_chunks"].append(chunk_cid)
+
+                        # Cancel from blockchain if requested
+                        if cancel_from_blockchain:
+                            try:
+                                substrate_client = SubstrateClient()
+                                tx_hash = await substrate_client.cancel_storage_request(
+                                    chunk_cid
+                                )
+
+                                # Add blockchain result
+                                if "chunk_results" not in result["blockchain_result"]:
+                                    result["blockchain_result"] = {}
+                                    result["blockchain_result"]["chunk_results"] = []
+
+                                # Handle special return values from cancel_storage_request
+                                if tx_hash == "no-blockchain-cancellation-available":
+                                    result["blockchain_result"]["chunk_results"].append(
+                                        {
+                                            "cid": chunk_cid,
+                                            "status": "not_available",
+                                            "message": "Blockchain cancellation not available",
+                                        }
+                                    )
+                                elif tx_hash.startswith("ipfs-unpinned-only"):
+                                    error_msg = tx_hash.replace(
+                                        "ipfs-unpinned-only-", ""
+                                    )
+                                    result["blockchain_result"]["chunk_results"].append(
+                                        {
+                                            "cid": chunk_cid,
+                                            "status": "failed",
+                                            "error": error_msg,
+                                        }
+                                    )
+                                else:
+                                    # Standard successful transaction
+                                    result["blockchain_result"]["chunk_results"].append(
+                                        {
+                                            "cid": chunk_cid,
+                                            "transaction_hash": tx_hash,
+                                            "status": "success",
+                                        }
+                                    )
+                            except Exception as e:
+                                print(
+                                    f"Warning: Failed to cancel blockchain storage for chunk {chunk_cid}: {e}"
+                                )
+
+                                if "chunk_results" not in result["blockchain_result"]:
+                                    result["blockchain_result"] = {}
+                                    result["blockchain_result"]["chunk_results"] = []
+
+                                result["blockchain_result"]["chunk_results"].append(
+                                    {
+                                        "cid": chunk_cid,
+                                        "error": str(e),
+                                        "status": "failed",
+                                    }
+                                )
+
+                        return True
+                    except Exception as e:
+                        error_msg = f"Failed to delete chunk {chunk_cid}: {e}"
+                        print(f"Warning: {error_msg}")
+
+                        # Record failure
+                        async with failed_chunks_lock:
+                            result["failed_chunks"].append(
+                                {"cid": chunk_cid, "error": str(e)}
+                            )
+
+                        return False
+
+            # Start deleting chunks in parallel
+            print(
+                f"Starting parallel deletion of {total_chunks} chunks with max {parallel_limit} concurrent operations"
+            )
+            delete_tasks = [delete_chunk(cid) for cid in chunks]
+            await asyncio.gather(*delete_tasks)
+
+            # Delete the metadata file itself
+            print(f"Unpinning metadata file: {metadata_cid}")
+            response = await self.client.unpin(metadata_cid)
+
+            print(">>>", response)
+            raise SystemExit
+
+            # Cancel metadata from blockchain if requested
+            if cancel_from_blockchain:
+                try:
+                    print(f"Canceling blockchain storage request for metadata file...")
+                    substrate_client = SubstrateClient()
+                    tx_hash = await substrate_client.cancel_storage_request(
+                        metadata_cid
+                    )
+
+                    # Handle special return values from cancel_storage_request
+                    if tx_hash == "no-blockchain-cancellation-available":
+                        print(
+                            "Blockchain cancellation not available for metadata, but IPFS unpinning was successful"
+                        )
+                        result["blockchain_result"] = {
+                            "status": "not_available",
+                            "message": "Blockchain cancellation not available, but IPFS unpinning was successful",
+                        }
+                    elif tx_hash.startswith("ipfs-unpinned-only"):
+                        error_msg = tx_hash.replace("ipfs-unpinned-only-", "")
+                        print(
+                            f"IPFS unpinning successful, but blockchain cancellation failed for metadata: {error_msg}"
+                        )
+                        result["blockchain_result"] = {
+                            "status": "failed",
+                            "error": error_msg,
+                            "message": "IPFS unpinning successful, but blockchain cancellation failed",
+                        }
+                    else:
+                        # Standard successful transaction
+                        result["blockchain_result"] = {
+                            "metadata_transaction_hash": tx_hash,
+                            "status": "success",
+                        }
+                        print(
+                            f"Successfully canceled blockchain storage for metadata file"
+                        )
+                except Exception as e:
+                    print(
+                        f"Warning: Failed to cancel blockchain storage for metadata file: {e}"
+                    )
+
+                    if not result["blockchain_result"]:
+                        result["blockchain_result"] = {}
+
+                    result["blockchain_result"]["metadata_error"] = str(e)
+                    result["blockchain_result"]["status"] = "failed"
+
+            # Calculate and record timing information
+            end_time = time.time()
+            duration = end_time - result["timing"]["start_time"]
+
+            result["timing"]["end_time"] = end_time
+            result["timing"]["duration_seconds"] = duration
+
+            deleted_count = len(result["deleted_chunks"])
+            failed_count = len(result["failed_chunks"])
+
+            print(f"Deletion complete in {duration:.2f} seconds!")
+            print(f"Successfully deleted: {deleted_count}/{total_chunks} chunks")
+
+            if failed_count > 0:
+                print(f"Failed to delete: {failed_count}/{total_chunks} chunks")
+
+            return result
+        except Exception as e:
+            # Record end time even if there was an error
+            result["timing"]["end_time"] = time.time()
+            result["timing"]["duration_seconds"] = (
+                result["timing"]["end_time"] - result["timing"]["start_time"]
+            )
+
+            error_msg = f"Error deleting erasure-coded file: {e}"
+            print(f"Error: {error_msg}")
+            raise RuntimeError(error_msg)