update functions to latest type changes

Author: ftheirs

sdk/msp-client/src/modules/buckets.ts

@@ -1,34 +1,108 @@
 import type { Bucket, FileListResponse, GetFilesOptions } from "../types.js";
 import { ModuleBase } from "../base.js";
+import { ensure0xPrefix } from "@storagehub-sdk/core";
 
 export class BucketsModule extends ModuleBase {
+  /** Recursively fix hex prefixes in FileTree structures */
+  private fixFileTree(item: any): any {
+    if (item.type === "file") {
+      return {
+        name: item.name,
+        type: item.type,
+        sizeBytes: item.sizeBytes,
+        fileKey: ensure0xPrefix(item.fileKey),
+        status: item.status
+      };
+    } else {
+      return {
+        name: item.name,
+        type: item.type,
+        children: item.children?.map((child: any) => this.fixFileTree(child)) || []
+      };
+    }
+  }
   /** List all buckets for the current authenticated user */
   async listBuckets(signal?: AbortSignal): Promise<Bucket[]> {
     const headers = await this.withAuth();
-    return this.ctx.http.get<Bucket[]>("/buckets", {
+    const wire = await this.ctx.http.get<
+      Array<{
+        bucketId: string;
+        name: string;
+        root: string;
+        isPublic: boolean;
+        sizeBytes: number;
+        valuePropId: string;
+        fileCount: number;
+      }>
+    >("/buckets", {
       ...(headers ? { headers } : {}),
       ...(signal ? { signal } : {})
     });
+
+    return wire.map((bucket) => ({
+      bucketId: ensure0xPrefix(bucket.bucketId),
+      name: bucket.name,
+      root: ensure0xPrefix(bucket.root),
+      isPublic: bucket.isPublic,
+      sizeBytes: bucket.sizeBytes,
+      valuePropId: bucket.valuePropId, // "unknown" string, not hex
+      fileCount: bucket.fileCount
+    }));
   }
 
   /** Get a specific bucket's metadata by its bucket ID */
   async getBucket(bucketId: string, signal?: AbortSignal): Promise<Bucket> {
     const headers = await this.withAuth();
     const path = `/buckets/${encodeURIComponent(bucketId)}`;
-    return this.ctx.http.get<Bucket>(path, {
+
+    const wire = await this.ctx.http.get<{
+      bucketId: string;
+      name: string;
+      root: string;
+      isPublic: boolean;
+      sizeBytes: number;
+      valuePropId: string;
+      fileCount: number;
+    }>(path, {
       ...(headers ? { headers } : {}),
       ...(signal ? { signal } : {})
     });
+
+    return {
+      bucketId: ensure0xPrefix(wire.bucketId),
+      name: wire.name,
+      root: ensure0xPrefix(wire.root),
+      isPublic: wire.isPublic,
+      sizeBytes: wire.sizeBytes,
+      valuePropId: wire.valuePropId, // "unknown" string, not hex
+      fileCount: wire.fileCount
+    };
   }
 
   /** List files/folders under a path for a bucket (root if no path) */
   async getFiles(bucketId: string, options?: GetFilesOptions): Promise<FileListResponse> {
     const headers = await this.withAuth();
     const path = `/buckets/${encodeURIComponent(bucketId)}/files`;
-    return this.ctx.http.get<FileListResponse>(path, {
+
+    const wire = await this.ctx.http.get<{
+      bucketId: string;
+      files: Array<{
+        name: string;
+        type: "file" | "folder";
+        sizeBytes?: number;
+        fileKey?: string;
+        status?: string;
+        children?: Array<any>;
+      }>;
+    }>(path, {
       ...(headers ? { headers } : {}),
       ...(options?.signal ? { signal: options.signal } : {}),
       ...(options?.path ? { query: { path: this.normalizePath(options.path) } } : {})
     });
+
+    return {
+      bucketId: ensure0xPrefix(wire.bucketId),
+      files: wire.files.map((file) => this.fixFileTree(file))
+    };
   }
 }

sdk/msp-client/src/modules/info.ts

@@ -6,6 +6,7 @@ import type {
   StatsResponse,
   ValueProp
 } from "../types.js";
+import { ensure0xPrefix } from "@storagehub-sdk/core";
 
 export class InfoModule extends ModuleBase {
   getHealth(signal?: AbortSignal): Promise<HealthStatus> {
@@ -15,10 +16,32 @@ export class InfoModule extends ModuleBase {
   }
 
   /** Get general MSP information */
-  getInfo(signal?: AbortSignal): Promise<InfoResponse> {
-    return this.ctx.http.get<InfoResponse>("/info", {
+  async getInfo(signal?: AbortSignal): Promise<InfoResponse> {
+    const wire = await this.ctx.http.get<{
+      client: string;
+      version: string;
+      mspId: string;
+      multiaddresses: string[];
+      ownerAccount: string;
+      paymentAccount: string;
+      status: string;
+      activeSince: number;
+      uptime: string;
+    }>("/info", {
       ...(signal ? { signal } : {})
     });
+
+    return {
+      client: wire.client,
+      version: wire.version,
+      mspId: ensure0xPrefix(wire.mspId),
+      multiaddresses: wire.multiaddresses,
+      ownerAccount: ensure0xPrefix(wire.ownerAccount), // Ensure 0x prefix (backend has it, but TypeScript needs guarantee)
+      paymentAccount: ensure0xPrefix(wire.paymentAccount), // Ensure 0x prefix (backend has it, but TypeScript needs guarantee)
+      status: wire.status,
+      activeSince: wire.activeSince,
+      uptime: wire.uptime
+    };
   }
 
   /** Get MSP statistics */