@cmdoss/memwal-sdk 0.6.0 → 0.6.2

package/src/services/MemoryIndexService.ts

@@ -568,18 +568,34 @@ export class MemoryIndexService {
   }
 
   /**
-   * Load index from storage
+   * Load index from storage (local or Walrus)
+   *
+   * @param userAddress - User's wallet address
+   * @param indexBlobId - Optional Walrus blob ID to load from cloud
    */
   async loadIndex(userAddress: string, indexBlobId?: string): Promise<void> {
     const hnswService = await this.getHnswService();
+
+    // If blobId provided, try to load from Walrus first
+    if (indexBlobId && 'loadFromWalrus' in hnswService) {
+      console.log(`📥 Attempting to load index from Walrus: ${indexBlobId}`);
+      const walrusLoaded = await (hnswService as any).loadFromWalrus(userAddress, indexBlobId);
+      if (walrusLoaded) {
+        console.log(`✅ Memory index loaded from Walrus for user ${userAddress}`);
+        return;
+      }
+      console.log(`⚠️ Walrus load failed, falling back to local storage`);
+    }
+
+    // Fallback to local storage
     const loaded = await hnswService.loadIndex(userAddress);
     if (loaded) {
-      console.log(`✅ Memory index loaded for user ${userAddress}`);
+      console.log(`✅ Memory index loaded from local storage for user ${userAddress}`);
     }
   }
 
   /**
-   * Save index to storage
+   * Save index to local storage
    */
   async saveIndex(userAddress: string): Promise<void> {
     const hnswService = await this.getHnswService();
@@ -587,6 +603,72 @@ export class MemoryIndexService {
     console.log(`✅ Memory index saved for user ${userAddress}`);
   }
 
+  /**
+   * Sync index to Walrus cloud storage
+   *
+   * @param userAddress - User's wallet address
+   * @returns Walrus blob ID if successful, null if Walrus is disabled
+   */
+  async syncToWalrus(userAddress: string): Promise<string | null> {
+    const hnswService = await this.getHnswService();
+
+    if (!('syncToWalrus' in hnswService)) {
+      console.warn('⚠️ HNSW service does not support Walrus sync');
+      return null;
+    }
+
+    const blobId = await (hnswService as any).syncToWalrus(userAddress);
+    if (blobId) {
+      console.log(`☁️ Memory index synced to Walrus: ${blobId}`);
+    }
+    return blobId;
+  }
+
+  /**
+   * Load index directly from Walrus cloud storage
+   *
+   * @param userAddress - User's wallet address
+   * @param blobId - Walrus blob ID
+   * @returns true if successfully loaded
+   */
+  async loadFromWalrus(userAddress: string, blobId: string): Promise<boolean> {
+    const hnswService = await this.getHnswService();
+
+    if (!('loadFromWalrus' in hnswService)) {
+      console.warn('⚠️ HNSW service does not support Walrus load');
+      return false;
+    }
+
+    const loaded = await (hnswService as any).loadFromWalrus(userAddress, blobId);
+    if (loaded) {
+      console.log(`☁️ Memory index loaded from Walrus: ${blobId}`);
+    }
+    return loaded;
+  }
+
+  /**
+   * Get the Walrus blob ID for a user's index (if backed up)
+   *
+   * @param userAddress - User's wallet address
+   * @returns Blob ID or null if not backed up
+   */
+  getWalrusBlobId(userAddress: string): string | null {
+    if (this.hnswService && 'getWalrusBlobId' in this.hnswService) {
+      return (this.hnswService as any).getWalrusBlobId(userAddress);
+    }
+    return null;
+  }
+
+  /**
+   * Check if Walrus backup is enabled
+   */
+  isWalrusEnabled(): boolean {
+    if (this.hnswService && 'isWalrusEnabled' in this.hnswService) {
+      return (this.hnswService as any).isWalrusEnabled();
+    }
+    return false;
+  }
+
   /**
    * Clear user's index
    */

package/src/services/StorageService.ts

@@ -15,7 +15,7 @@
 import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
 import { Transaction } from '@mysten/sui/transactions';
 import { WalrusClient, WalrusFile } from '@mysten/walrus';
-import type { Signer } from '@mysten/sui/cryptography';
+import type { UnifiedSigner } from '../client/signers/UnifiedSigner';
 import type { ClientWithExtensions } from '@mysten/sui/experimental';
 import type { SealService } from '../infrastructure/seal/SealService';
 import type { BatchService } from './BatchService';
@@ -71,7 +71,7 @@ export interface WalrusUploadResult {
 }
 
 export interface BlobUploadOptions {
-  signer: Signer;
+  signer: UnifiedSigner;
   epochs?: number;
   deletable?: boolean;
   useUploadRelay?: boolean;
@@ -817,7 +817,7 @@ export class StorageService {
       summary?: string;
     }>,
     options: {
-      signer: Signer;
+      signer: UnifiedSigner;
       epochs?: number;
       userAddress: string;
     }
@@ -856,7 +856,7 @@ export class StorageService {
       tags?: Record<string, string>;
     }>,
     options: {
-      signer: Signer;
+      signer: UnifiedSigner;
       epochs?: number;
       userAddress: string;
     }
@@ -924,7 +924,7 @@ export class StorageService {
   async setBlobAttributes(
     blobObjectId: string,
     attributes: Record<string, string>,
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     return this.blobAttributes.setBlobAttributes(blobObjectId, attributes, signer);
   }
@@ -945,7 +945,7 @@ export class StorageService {
   async updateBlobAttributes(
     blobObjectId: string,
     attributes: Record<string, string>,
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     return this.blobAttributes.updateBlobAttributes(blobObjectId, attributes, signer);
   }
@@ -956,7 +956,7 @@ export class StorageService {
   async removeBlobAttributes(
     blobObjectId: string,
     attributeKeys: string[],
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     return this.blobAttributes.removeBlobAttributes(blobObjectId, attributeKeys, signer);
   }
@@ -1009,7 +1009,7 @@ export class StorageService {
   async attachMetadataToBlob(
     blobId: string,
     metadata: WalrusMemoryMetadata,
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<{ digest: string; effects: any }> {
     const walrusPackageId = this.config.network === 'mainnet'
       ? '0x<mainnet-walrus-package-id>'

package/src/services/VectorService.ts

@@ -238,14 +238,14 @@ export class VectorService {
 
     const searchTime = performance.now() - startTime;
 
-    // Get metadata from local cache
+    // Get metadata - prefer HNSW service metadata (loaded from disk) over local cache
     return {
       results: searchResults.map((result) => ({
         memoryId: result.vectorId.toString(),
         vectorId: result.vectorId,
         similarity: result.score,
         distance: result.distance,
-        metadata: entry?.metadata.get(result.vectorId) || result.metadata
+        metadata: result.metadata || entry?.metadata.get(result.vectorId)
       })),
       searchStats: {
         searchTime,

package/src/services/storage/BlobAttributesManager.ts

@@ -12,8 +12,8 @@
  */
 
 import type { SuiClient } from '@mysten/sui/client';
-import type { Signer } from '@mysten/sui/cryptography';
 import { Transaction } from '@mysten/sui/transactions';
+import type { UnifiedSigner } from '../../client/signers/UnifiedSigner';
 
 export interface BlobQueryResult {
   blobObjectId: string;
@@ -44,7 +44,7 @@ export class BlobAttributesManager {
   async setBlobAttributes(
     blobObjectId: string,
     attributes: Record<string, string>,
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     try {
       console.log(`🏷️  Setting ${Object.keys(attributes).length} attributes on blob ${blobObjectId.slice(0, 10)}...`);
@@ -69,12 +69,9 @@ export class BlobAttributesManager {
         console.log(`   ✓ ${key}: ${value.slice(0, 50)}${value.length > 50 ? '...' : ''}`);
       }
 
-      tx.setSender(signer.toSuiAddress());
+      tx.setSender(signer.getAddress());
 
-      const result = await signer.signAndExecuteTransaction({
-        transaction: tx,
-        client: this.suiClient,
-      });
+      const result = await signer.signAndExecuteTransaction(tx);
 
       console.log(`✅ Attributes set successfully!`);
       console.log(`   Transaction: ${result.digest}`);
@@ -163,7 +160,7 @@ export class BlobAttributesManager {
   async updateBlobAttributes(
     blobObjectId: string,
     attributes: Record<string, string>,
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     try {
       console.log(`📝 Updating ${Object.keys(attributes).length} attributes on blob ${blobObjectId.slice(0, 10)}...`);
@@ -202,12 +199,9 @@ export class BlobAttributesManager {
         console.log(`   ✓ Updated ${key}: ${value.slice(0, 50)}${value.length > 50 ? '...' : ''}`);
       }
 
-      tx.setSender(signer.toSuiAddress());
+      tx.setSender(signer.getAddress());
 
-      const result = await signer.signAndExecuteTransaction({
-        transaction: tx,
-        client: this.suiClient,
-      });
+      const result = await signer.signAndExecuteTransaction(tx);
 
       console.log(`✅ Attributes updated successfully!`);
       console.log(`   Transaction: ${result.digest}`);
@@ -226,7 +220,7 @@ export class BlobAttributesManager {
   async removeBlobAttributes(
     blobObjectId: string,
     attributeKeys: string[],
-    signer: Signer
+    signer: UnifiedSigner
   ): Promise<string> {
     try {
       console.log(`🗑️  Removing ${attributeKeys.length} attributes from blob ${blobObjectId.slice(0, 10)}...`);
@@ -249,12 +243,9 @@ export class BlobAttributesManager {
         console.log(`   ✓ Removed ${key}`);
       }
 
-      tx.setSender(signer.toSuiAddress());
+      tx.setSender(signer.getAddress());
 
-      const result = await signer.signAndExecuteTransaction({
-        transaction: tx,
-        client: this.suiClient,
-      });
+      const result = await signer.signAndExecuteTransaction(tx);
 
       console.log(`✅ Attributes removed successfully!`);
       console.log(`   Transaction: ${result.digest}`);

package/src/services/storage/QuiltBatchManager.ts

@@ -8,7 +8,7 @@
  * - Batch upload with ~90% gas savings (single transaction for multiple files)
  * - Tag-based filtering at the Walrus level
  * - Multi-file retrieval via quiltPatchId
- * - Browser-compatible using writeFilesFlow
+ * - Browser-compatible using writeFilesFlow (2 user signatures)
  *
  * Quilt Structure:
  * - quiltId: ID of the entire batch (blob containing all files)
@@ -16,13 +16,19 @@
  * - identifier: Human-readable name for each file
  * - tags: Metadata for filtering (category, importance, etc.)
  *
+ * Upload Flow (writeFilesFlow - works with DappKitSigner):
+ * 1. encode() - Encode files into blob format (no signature)
+ * 2. register() - Register blob on-chain (USER SIGNS - Transaction 1)
+ * 3. upload() - Upload to Walrus storage nodes (no signature)
+ * 4. certify() - Certify upload on-chain (USER SIGNS - Transaction 2)
+ *
  * @see https://sdk.mystenlabs.com/walrus/index
  */
 
 import { WalrusClient, WalrusFile } from '@mysten/walrus';
-import type { Signer } from '@mysten/sui/cryptography';
 import type { ClientWithExtensions } from '@mysten/sui/experimental';
 import type { SuiClient } from '@mysten/sui/client';
+import type { UnifiedSigner } from '../../client/signers/UnifiedSigner';
 
 // ============================================================================
 // Types
@@ -40,7 +46,7 @@ export interface BatchMemory {
 }
 
 export interface QuiltUploadOptions {
-  signer: Signer;
+  signer: UnifiedSigner;
   epochs?: number;
   userAddress: string;
   deletable?: boolean;
@@ -119,7 +125,13 @@ export class QuiltBatchManager {
   // ==========================================================================
 
   /**
-   * Upload batch of memories as a Quilt
+   * Upload batch of memories as a Quilt using writeFilesFlow
+   *
+   * Uses the writeFilesFlow pattern which works with DappKitSigner:
+   * 1. encode() - Encode files (no signature)
+   * 2. register() - Register blob on-chain (USER SIGNS)
+   * 3. upload() - Upload to storage nodes (no signature)
+   * 4. certify() - Certify upload on-chain (USER SIGNS)
    *
    * Each memory becomes a WalrusFile with:
    * - Identifier: unique file name (memory-{timestamp}-{index}-{random}.json)
@@ -137,7 +149,7 @@ export class QuiltBatchManager {
     const startTime = performance.now();
     let totalSize = 0;
 
-    console.log(`📦 Uploading batch of ${memories.length} memories as Quilt...`);
+    console.log(`📦 Uploading batch of ${memories.length} memories as Quilt (writeFilesFlow)...`);
 
     try {
       // Create WalrusFile for each memory with plaintext tags
@@ -181,42 +193,78 @@ export class QuiltBatchManager {
       console.log(`   Total size: ${(totalSize / 1024).toFixed(2)} KB`);
       console.log(`   Using upload relay: ${this.useUploadRelay}`);
 
-      // Upload as Quilt using writeFiles
+      // Use writeFilesFlow pattern (works with DappKitSigner)
       const walrusClient = this.useUploadRelay
         ? this.walrusWithRelay
         : this.walrusWithoutRelay;
 
-      const results = await walrusClient.writeFiles({
-        files,
+      // Step 1: Create flow and encode files (no signature needed)
+      console.log(`   Step 1/4: Encoding files...`);
+      const flow = walrusClient.writeFilesFlow({ files });
+      await flow.encode();
+      console.log(`   ✓ Files encoded`);
+
+      // Step 2: Register blob on-chain (USER SIGNS - Transaction 1)
+      console.log(`   Step 2/4: Registering blob (requires signature)...`);
+      const registerTx = flow.register({
         epochs: options.epochs || this.epochs,
-        deletable: options.deletable ?? true,
-        signer: options.signer
+        owner: options.userAddress,
+        deletable: options.deletable ?? true
       });
 
+      const registerResult = await options.signer.signAndExecuteTransaction(registerTx);
+      console.log(`   ✓ Blob registered, digest: ${registerResult.digest}`);
+
+      // Step 3: Upload to Walrus storage nodes (no signature needed)
+      console.log(`   Step 3/4: Uploading to storage nodes...`);
+      await flow.upload({ digest: registerResult.digest });
+      console.log(`   ✓ Uploaded to storage nodes`);
+
+      // Step 4: Certify upload on-chain (USER SIGNS - Transaction 2)
+      console.log(`   Step 4/4: Certifying upload (requires signature)...`);
+      const certifyTx = flow.certify();
+
+      if (certifyTx) {
+        const certifyResult = await options.signer.signAndExecuteTransaction(certifyTx);
+        console.log(`   ✓ Upload certified, digest: ${certifyResult.digest}`);
+      } else {
+        console.log(`   ✓ No certification needed (already certified)`);
+      }
+
+      // Get uploaded files info from flow
+      const uploadedFilesInfo = await flow.listFiles();
+
       const uploadTimeMs = performance.now() - startTime;
       const gasSaved = memories.length > 1
         ? `~${((1 - 1 / memories.length) * 100).toFixed(0)}%`
         : '0%';
 
       console.log(`✅ Quilt upload successful!`);
-      console.log(`   Quilt ID: ${results[0]?.id || 'N/A'}`);
-      console.log(`   Blob ID: ${results[0]?.blobId || 'N/A'}`);
-      console.log(`   Files uploaded: ${results.length}`);
+      console.log(`   Files uploaded: ${uploadedFilesInfo.length}`);
       console.log(`   Upload time: ${uploadTimeMs.toFixed(1)}ms`);
       console.log(`   Gas saved: ${gasSaved} vs individual uploads`);
 
-      // Build file results with identifiers (use original files array, not WalrusFile objects)
+      // Build file results using original WalrusFile objects for metadata
+      // Use shared quiltId as blobId - SDK can only read via getBlob(quiltId).files()
+      // Match files by identifier when reading
+      const quiltId = uploadedFilesInfo[0]?.blobId || '';
+
       const fileResults: QuiltFileResult[] = await Promise.all(
-        results.map(async (r, i) => {
-          // Get identifier from original WalrusFile object
-          const file = files[i];
-          const identifier = await file?.getIdentifier() || `file-${i}`;
-          const tags = await file?.getTags() || {};
+        files.map(async (originalFile, i) => {
+          const identifier = await originalFile.getIdentifier() || `file-${i}`;
+          const tags = await originalFile.getTags() || {};
+          const fileInfo = uploadedFilesInfo[i];
+
+          // quiltPatchId is stored for reference but not used for retrieval
+          const quiltPatchId = fileInfo?.id || '';
+
+          console.log(`   File ${i}: identifier=${identifier}, quiltId=${quiltId.substring(0, 20)}...`);
 
           return {
             identifier,
-            blobId: r.blobId,
-            quiltPatchId: undefined, // Not available from writeFiles result
+            // Use shared quiltId as blobId - read via getBlob(quiltId).files()
+            blobId: quiltId,
+            quiltPatchId,
             tags: Object.fromEntries(
               Object.entries(tags).map(([k, v]) => [k, String(v)])
             ),
@@ -226,8 +274,8 @@ export class QuiltBatchManager {
       );
 
       return {
-        quiltId: results[0]?.id || results[0]?.blobId,
-        blobObjectId: results[0]?.blobObject?.id?.id,
+        quiltId,
+        blobObjectId: undefined, // Not available from flow
         files: fileResults,
         uploadTimeMs,
         totalSize,
@@ -241,7 +289,13 @@ export class QuiltBatchManager {
   }
 
   /**
-   * Upload raw files as a Quilt (non-memory data)
+   * Upload raw files as a Quilt using writeFilesFlow
+   *
+   * Uses the writeFilesFlow pattern which works with DappKitSigner:
+   * 1. encode() - Encode files (no signature)
+   * 2. register() - Register blob on-chain (USER SIGNS)
+   * 3. upload() - Upload to storage nodes (no signature)
+   * 4. certify() - Certify upload on-chain (USER SIGNS)
    *
    * @param files - Array of { identifier, data, tags }
    * @param options - Upload options
@@ -258,7 +312,7 @@ export class QuiltBatchManager {
     const startTime = performance.now();
     let totalSize = 0;
 
-    console.log(`📁 Uploading ${files.length} files as Quilt...`);
+    console.log(`📁 Uploading ${files.length} files as Quilt (writeFilesFlow)...`);
 
     try {
       const walrusFiles = files.map(file => {
@@ -276,28 +330,86 @@ export class QuiltBatchManager {
         });
       });
 
+      // Use writeFilesFlow pattern (works with DappKitSigner)
       const walrusClient = this.useUploadRelay
         ? this.walrusWithRelay
         : this.walrusWithoutRelay;
 
-      const results = await walrusClient.writeFiles({
-        files: walrusFiles,
+      // Step 1: Create flow and encode files (no signature needed)
+      console.log(`   Step 1/4: Encoding files...`);
+      const flow = walrusClient.writeFilesFlow({ files: walrusFiles });
+      await flow.encode();
+      console.log(`   ✓ Files encoded`);
+
+      // Step 2: Register blob on-chain (USER SIGNS - Transaction 1)
+      console.log(`   Step 2/4: Registering blob (requires signature)...`);
+      const registerTx = flow.register({
         epochs: options.epochs || this.epochs,
-        deletable: options.deletable ?? true,
-        signer: options.signer
+        owner: options.userAddress,
+        deletable: options.deletable ?? true
       });
 
+      const registerResult = await options.signer.signAndExecuteTransaction(registerTx);
+      console.log(`   ✓ Blob registered, digest: ${registerResult.digest}`);
+
+      // Step 3: Upload to Walrus storage nodes (no signature needed)
+      console.log(`   Step 3/4: Uploading to storage nodes...`);
+      await flow.upload({ digest: registerResult.digest });
+      console.log(`   ✓ Uploaded to storage nodes`);
+
+      // Step 4: Certify upload on-chain (USER SIGNS - Transaction 2)
+      console.log(`   Step 4/4: Certifying upload (requires signature)...`);
+      const certifyTx = flow.certify();
+
+      if (certifyTx) {
+        const certifyResult = await options.signer.signAndExecuteTransaction(certifyTx);
+        console.log(`   ✓ Upload certified, digest: ${certifyResult.digest}`);
+      } else {
+        console.log(`   ✓ No certification needed (already certified)`);
+      }
+
+      // Get uploaded files info from flow
+      const uploadedFilesInfo = await flow.listFiles();
+
       const uploadTimeMs = performance.now() - startTime;
 
+      console.log(`✅ Files batch upload successful!`);
+      console.log(`   Files uploaded: ${uploadedFilesInfo.length}`);
+      console.log(`   Upload time: ${uploadTimeMs.toFixed(1)}ms`);
+
+      // Build file results using original WalrusFile objects for metadata
+      // Use shared quiltId as blobId - SDK can only read via getBlob(quiltId).files()
+      // Match files by identifier when reading
+      const quiltId = uploadedFilesInfo[0]?.blobId || '';
+
+      const fileResults: QuiltFileResult[] = await Promise.all(
+        walrusFiles.map(async (originalFile, i) => {
+          const identifier = await originalFile.getIdentifier() || files[i]?.identifier || `file-${i}`;
+          const tags = await originalFile.getTags() || {};
+          const fileInfo = uploadedFilesInfo[i];
+
+          // quiltPatchId is stored for reference but not used for retrieval
+          const quiltPatchId = fileInfo?.id || '';
+
+          console.log(`   File ${i}: identifier=${identifier}, quiltId=${quiltId.substring(0, 20)}...`);
+
+          return {
+            identifier,
+            // Use shared quiltId as blobId - read via getBlob(quiltId).files()
+            blobId: quiltId,
+            quiltPatchId,
+            tags: Object.fromEntries(
+              Object.entries(tags).map(([k, v]) => [k, String(v)])
+            ),
+            size: files[i]?.data.length || 0
+          };
+        })
+      );
+
       return {
-        quiltId: results[0]?.id || results[0]?.blobId,
-        blobObjectId: results[0]?.blobObject?.id?.id,
-        files: results.map((r, i) => ({
-          identifier: files[i].identifier,
-          blobId: r.blobId,
-          tags: files[i].tags || {},
-          size: files[i].data.length
-        })),
+        quiltId,
+        blobObjectId: undefined, // Not available from flow
+        files: fileResults,
         uploadTimeMs,
         totalSize,
         gasSaved: files.length > 1 ? `~${((1 - 1 / files.length) * 100).toFixed(0)}%` : '0%'
@@ -316,14 +428,19 @@ export class QuiltBatchManager {
   /**
    * Retrieve all files from a Quilt
    *
-   * @param quiltId - The Quilt blob ID
+   * Uses getBlob().files() pattern which correctly parses Quilt structure
+   * and returns individual files with their identifiers and tags.
+   *
+   * @param quiltId - The Quilt blob ID (shared blobId)
    * @returns Array of WalrusFile objects
    */
   async getQuiltFiles(quiltId: string): Promise<Array<WalrusFile>> {
     try {
       console.log(`📂 Retrieving files from Quilt ${quiltId}...`);
 
-      const files = await this.suiClient.walrus.getFiles({ ids: [quiltId] });
+      // Use getBlob().files() to correctly parse Quilt and get individual files
+      const blob = await this.suiClient.walrus.getBlob({ blobId: quiltId });
+      const files = await blob.files();
 
       console.log(`✅ Retrieved ${files.length} files from Quilt`);
 
@@ -338,7 +455,9 @@ export class QuiltBatchManager {
   /**
    * Retrieve a specific file by identifier from a Quilt
    *
-   * @param quiltId - The Quilt blob ID
+   * Uses getBlob().files() to get all files then matches by identifier.
+   *
+   * @param quiltId - The Quilt blob ID (shared blobId)
    * @param identifier - The file identifier within the quilt
    * @returns QuiltRetrieveResult with content and metadata
    */
@@ -351,21 +470,26 @@ export class QuiltBatchManager {
     try {
       console.log(`📄 Retrieving file "${identifier}" from Quilt ${quiltId}...`);
 
-      // Get all files from quilt
-      const files = await this.suiClient.walrus.getFiles({ ids: [quiltId] });
+      // Get all files from quilt using getBlob().files()
+      const blob = await this.suiClient.walrus.getBlob({ blobId: quiltId });
+      const files = await blob.files();
 
       // Find file by identifier
-      const file = files.find(async f => {
+      let matchingFile: WalrusFile | undefined;
+      for (const f of files) {
         const fileIdentifier = await f.getIdentifier();
-        return fileIdentifier === identifier;
-      });
+        if (fileIdentifier === identifier) {
+          matchingFile = f;
+          break;
+        }
+      }
 
-      if (!file) {
+      if (!matchingFile) {
         throw new Error(`File "${identifier}" not found in Quilt`);
       }
 
-      const content = await file.bytes();
-      const tags = await file.getTags();
+      const content = await matchingFile.bytes();
+      const tags = await matchingFile.getTags();
       const retrievalTimeMs = performance.now() - startTime;
 
       console.log(`✅ Retrieved file "${identifier}" (${content.length} bytes)`);
@@ -386,14 +510,18 @@ export class QuiltBatchManager {
   /**
    * List all patches in a Quilt with their metadata
    *
-   * @param quiltId - The Quilt blob ID
+   * Uses getBlob().files() to correctly parse Quilt structure.
+   *
+   * @param quiltId - The Quilt blob ID (shared blobId)
    * @returns Array of QuiltListResult with identifiers and tags
    */
   async listQuiltPatches(quiltId: string): Promise<QuiltListResult[]> {
     try {
       console.log(`📋 Listing patches in Quilt ${quiltId}...`);
 
-      const files = await this.suiClient.walrus.getFiles({ ids: [quiltId] });
+      // Use getBlob().files() to correctly parse Quilt
+      const blob = await this.suiClient.walrus.getBlob({ blobId: quiltId });
+      const files = await blob.files();
 
       const results: QuiltListResult[] = await Promise.all(
         files.map(async (file) => {