@gethashd/bytecave-browser 1.0.50 → 1.0.52

package/dist/{chunk-2FNF5T75.js → chunk-XPZKBTJA.js}

@@ -6352,37 +6352,21 @@ var StorageWebTransportClient = class {
   }
   /**
    * Convert libp2p multihash cert hash to SHA-256 ArrayBuffer for WebTransport
-   * The certhash in multiaddr is base58-encoded multihash, we need to decode it
+   * The certhash in multiaddr format is: uEi<hex-hash>
+   * where 'u' = base32 multibase, 'Ei' = multihash prefix for SHA-256
    */
   async certHashToSHA256(multihash) {
     try {
-      const base58Data = multihash.startsWith("uEi") ? multihash.slice(3) : multihash;
-      const hexHash = this.base58ToHex(base58Data);
+      let hexHash = multihash.startsWith("uEi") ? multihash.slice(3) : multihash;
       const bytes = new Uint8Array(hexHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+      console.log("[WebTransport] Decoded certificate hash:", hexHash);
+      console.log("[WebTransport] Hash bytes length:", bytes.length);
       return bytes.buffer;
     } catch (error) {
       console.error("[WebTransport] Failed to convert cert hash:", error);
-      return new Uint8Array(32).buffer;
+      throw new Error("Failed to decode certificate hash");
     }
   }
-  /**
-   * Simple base58 to hex converter (simplified version)
-   */
-  base58ToHex(base58) {
-    const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    let num = BigInt(0);
-    for (let i = 0; i < base58.length; i++) {
-      const char = base58[i];
-      const value = alphabet.indexOf(char);
-      if (value === -1) {
-        throw new Error(`Invalid base58 character: ${char}`);
-      }
-      num = num * BigInt(58) + BigInt(value);
-    }
-    let hex = num.toString(16);
-    if (hex.length % 2) hex = "0" + hex;
-    return hex;
-  }
 };
 
 // src/contracts/ContentRegistry.ts
@@ -7014,14 +6998,48 @@ Nonce: ${nonce}`;
     try {
       const peerInfo = this.knownPeers.get(peerId);
       const relayAddrs = peerInfo?.relayAddrs;
-      if (relayAddrs && relayAddrs.length > 0 && this.node) {
-        console.log("[ByteCave] Dialing peer through relay:", peerId.slice(0, 12), relayAddrs[0]);
-        try {
-          const ma = multiaddr(relayAddrs[0]);
-          await this.node.dial(ma);
-          console.log("[ByteCave] Successfully dialed peer through relay");
-        } catch (dialError) {
-          console.warn("[ByteCave] Failed to dial through relay:", dialError);
+      const multiaddrs = peerInfo?.multiaddrs;
+      if (this.node) {
+        const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
+        if (connections.length === 0) {
+          console.log("[ByteCave] No existing connection to peer, attempting to dial");
+          if (relayAddrs && relayAddrs.length > 0) {
+            console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
+            try {
+              const ma = multiaddr(relayAddrs[0]);
+              await this.node.dial(ma);
+              console.log("[ByteCave] \u2713 Connected via relay");
+            } catch (dialError) {
+              console.warn("[ByteCave] Relay dial failed:", dialError.message);
+              if (multiaddrs && multiaddrs.length > 0) {
+                const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+                if (wtAddr) {
+                  console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
+                  try {
+                    const ma = multiaddr(wtAddr);
+                    await this.node.dial(ma);
+                    console.log("[ByteCave] \u2713 Connected via WebTransport");
+                  } catch (wtError) {
+                    console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
+                  }
+                }
+              }
+            }
+          } else if (multiaddrs && multiaddrs.length > 0) {
+            const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+            if (wtAddr) {
+              console.log("[ByteCave] Trying WebTransport address (no relay):", wtAddr.slice(0, 60));
+              try {
+                const ma = multiaddr(wtAddr);
+                await this.node.dial(ma);
+                console.log("[ByteCave] \u2713 Connected via WebTransport");
+              } catch (wtError) {
+                console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
+              }
+            }
+          }
+        } else {
+          console.log("[ByteCave] Already connected to peer via", connections[0].remoteAddr.toString().slice(0, 60));
         }
       }
       const health = await p2pProtocolClient.getHealthFromPeer(peerId);

package/dist/index.cjs

@@ -6405,37 +6405,21 @@ var StorageWebTransportClient = class {
   }
   /**
    * Convert libp2p multihash cert hash to SHA-256 ArrayBuffer for WebTransport
-   * The certhash in multiaddr is base58-encoded multihash, we need to decode it
+   * The certhash in multiaddr format is: uEi<hex-hash>
+   * where 'u' = base32 multibase, 'Ei' = multihash prefix for SHA-256
    */
   async certHashToSHA256(multihash) {
     try {
-      const base58Data = multihash.startsWith("uEi") ? multihash.slice(3) : multihash;
-      const hexHash = this.base58ToHex(base58Data);
+      let hexHash = multihash.startsWith("uEi") ? multihash.slice(3) : multihash;
       const bytes = new Uint8Array(hexHash.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+      console.log("[WebTransport] Decoded certificate hash:", hexHash);
+      console.log("[WebTransport] Hash bytes length:", bytes.length);
       return bytes.buffer;
     } catch (error) {
       console.error("[WebTransport] Failed to convert cert hash:", error);
-      return new Uint8Array(32).buffer;
+      throw new Error("Failed to decode certificate hash");
     }
   }
-  /**
-   * Simple base58 to hex converter (simplified version)
-   */
-  base58ToHex(base58) {
-    const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    let num = BigInt(0);
-    for (let i = 0; i < base58.length; i++) {
-      const char = base58[i];
-      const value = alphabet.indexOf(char);
-      if (value === -1) {
-        throw new Error(`Invalid base58 character: ${char}`);
-      }
-      num = num * BigInt(58) + BigInt(value);
-    }
-    let hex = num.toString(16);
-    if (hex.length % 2) hex = "0" + hex;
-    return hex;
-  }
 };
 
 // src/contracts/ContentRegistry.ts
@@ -7067,14 +7051,48 @@ Nonce: ${nonce}`;
     try {
       const peerInfo = this.knownPeers.get(peerId);
       const relayAddrs = peerInfo?.relayAddrs;
-      if (relayAddrs && relayAddrs.length > 0 && this.node) {
-        console.log("[ByteCave] Dialing peer through relay:", peerId.slice(0, 12), relayAddrs[0]);
-        try {
-          const ma = (0, import_multiaddr.multiaddr)(relayAddrs[0]);
-          await this.node.dial(ma);
-          console.log("[ByteCave] Successfully dialed peer through relay");
-        } catch (dialError) {
-          console.warn("[ByteCave] Failed to dial through relay:", dialError);
+      const multiaddrs = peerInfo?.multiaddrs;
+      if (this.node) {
+        const connections = this.node.getConnections().filter((c) => c.remotePeer.toString() === peerId);
+        if (connections.length === 0) {
+          console.log("[ByteCave] No existing connection to peer, attempting to dial");
+          if (relayAddrs && relayAddrs.length > 0) {
+            console.log("[ByteCave] Trying relay address:", relayAddrs[0].slice(0, 60));
+            try {
+              const ma = (0, import_multiaddr.multiaddr)(relayAddrs[0]);
+              await this.node.dial(ma);
+              console.log("[ByteCave] \u2713 Connected via relay");
+            } catch (dialError) {
+              console.warn("[ByteCave] Relay dial failed:", dialError.message);
+              if (multiaddrs && multiaddrs.length > 0) {
+                const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+                if (wtAddr) {
+                  console.log("[ByteCave] Trying WebTransport address:", wtAddr.slice(0, 60));
+                  try {
+                    const ma = (0, import_multiaddr.multiaddr)(wtAddr);
+                    await this.node.dial(ma);
+                    console.log("[ByteCave] \u2713 Connected via WebTransport");
+                  } catch (wtError) {
+                    console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
+                  }
+                }
+              }
+            }
+          } else if (multiaddrs && multiaddrs.length > 0) {
+            const wtAddr = multiaddrs.find((addr) => addr.includes("/webtransport"));
+            if (wtAddr) {
+              console.log("[ByteCave] Trying WebTransport address (no relay):", wtAddr.slice(0, 60));
+              try {
+                const ma = (0, import_multiaddr.multiaddr)(wtAddr);
+                await this.node.dial(ma);
+                console.log("[ByteCave] \u2713 Connected via WebTransport");
+              } catch (wtError) {
+                console.warn("[ByteCave] WebTransport dial failed:", wtError.message);
+              }
+            }
+          }
+        } else {
+          console.log("[ByteCave] Already connected to peer via", connections[0].remoteAddr.toString().slice(0, 60));
         }
       }
       const health = await p2pProtocolClient.getHealthFromPeer(peerId);

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-2FNF5T75.js";
+} from "./chunk-XPZKBTJA.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-2FNF5T75.js";
+} from "../chunk-XPZKBTJA.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/dist/storage-webtransport.d.ts

@@ -40,11 +40,8 @@ export declare class StorageWebTransportClient {
     private extractCertHash;
     /**
      * Convert libp2p multihash cert hash to SHA-256 ArrayBuffer for WebTransport
-     * The certhash in multiaddr is base58-encoded multihash, we need to decode it
+     * The certhash in multiaddr format is: uEi<hex-hash>
+     * where 'u' = base32 multibase, 'Ei' = multihash prefix for SHA-256
      */
     private certHashToSHA256;
-    /**
-     * Simple base58 to hex converter (simplified version)
-     */
-    private base58ToHex;
 }

package/dist/types.d.ts

@@ -23,6 +23,10 @@ export interface PeerInfo {
     nodeUrl?: string;
     isRegistered?: boolean;
     owner?: string;
+    multiaddrs?: string[];
+    httpEndpoint?: string;
+    relayAddrs?: string[];
+    onChainNodeId?: string;
 }
 export interface StoreResult {
     success: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.50",
+  "version": "1.0.52",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/client.ts

@@ -811,19 +811,59 @@ Nonce: ${nonce}`;
     uptime: number;
   } | null> {
     try {
-      // Check if we have relay addresses for this peer
+      // Check if we have addresses for this peer
       const peerInfo = this.knownPeers.get(peerId);
       const relayAddrs = (peerInfo as any)?.relayAddrs;
+      const multiaddrs = peerInfo?.multiaddrs;
       
-      // If we have relay addresses, dial through relay first
-      if (relayAddrs && relayAddrs.length > 0 && this.node) {
-        console.log('[ByteCave] Dialing peer through relay:', peerId.slice(0, 12), relayAddrs[0]);
-        try {
-          const ma = multiaddr(relayAddrs[0]);
-          await this.node.dial(ma as any);
-          console.log('[ByteCave] Successfully dialed peer through relay');
-        } catch (dialError) {
-          console.warn('[ByteCave] Failed to dial through relay:', dialError);
+      // Try to dial the peer if not already connected
+      if (this.node) {
+        const connections = this.node.getConnections().filter(c => c.remotePeer.toString() === peerId);
+        
+        if (connections.length === 0) {
+          console.log('[ByteCave] No existing connection to peer, attempting to dial');
+          
+          // Try relay addresses first (if available)
+          if (relayAddrs && relayAddrs.length > 0) {
+            console.log('[ByteCave] Trying relay address:', relayAddrs[0].slice(0, 60));
+            try {
+              const ma = multiaddr(relayAddrs[0]);
+              await this.node.dial(ma as any);
+              console.log('[ByteCave] ✓ Connected via relay');
+            } catch (dialError: any) {
+              console.warn('[ByteCave] Relay dial failed:', dialError.message);
+              
+              // Fallback to WebTransport if relay fails
+              if (multiaddrs && multiaddrs.length > 0) {
+                const wtAddr = multiaddrs.find((addr: string) => addr.includes('/webtransport'));
+                if (wtAddr) {
+                  console.log('[ByteCave] Trying WebTransport address:', wtAddr.slice(0, 60));
+                  try {
+                    const ma = multiaddr(wtAddr);
+                    await this.node.dial(ma as any);
+                    console.log('[ByteCave] ✓ Connected via WebTransport');
+                  } catch (wtError: any) {
+                    console.warn('[ByteCave] WebTransport dial failed:', wtError.message);
+                  }
+                }
+              }
+            }
+          } else if (multiaddrs && multiaddrs.length > 0) {
+            // No relay addresses, try WebTransport directly
+            const wtAddr = multiaddrs.find((addr: string) => addr.includes('/webtransport'));
+            if (wtAddr) {
+              console.log('[ByteCave] Trying WebTransport address (no relay):', wtAddr.slice(0, 60));
+              try {
+                const ma = multiaddr(wtAddr);
+                await this.node.dial(ma as any);
+                console.log('[ByteCave] ✓ Connected via WebTransport');
+              } catch (wtError: any) {
+                console.warn('[ByteCave] WebTransport dial failed:', wtError.message);
+              }
+            }
+          }
+        } else {
+          console.log('[ByteCave] Already connected to peer via', connections[0].remoteAddr.toString().slice(0, 60));
         }
       }
       

package/src/storage-webtransport.ts

@@ -192,55 +192,25 @@ export class StorageWebTransportClient {
 
   /**
    * Convert libp2p multihash cert hash to SHA-256 ArrayBuffer for WebTransport
-   * The certhash in multiaddr is base58-encoded multihash, we need to decode it
+   * The certhash in multiaddr format is: uEi<hex-hash>
+   * where 'u' = base32 multibase, 'Ei' = multihash prefix for SHA-256
    */
   private async certHashToSHA256(multihash: string): Promise<ArrayBuffer> {
     try {
-      // The multihash format is: uEi<base58-encoded-data>
-      // For WebTransport, we need the raw SHA-256 hash bytes
+      // Remove 'uEi' prefix to get the raw hex hash
+      // Format: uEi733dc9ebf43a04ad3bc692f104cf6ccc228a062fcd7aa43fc370f9c3c67e3bfc
+      let hexHash = multihash.startsWith('uEi') ? multihash.slice(3) : multihash;
       
-      // Remove 'uEi' prefix (multibase + multihash prefix for SHA-256)
-      const base58Data = multihash.startsWith('uEi') ? multihash.slice(3) : multihash;
-      
-      // Decode base58 to get the raw hash
-      // For now, we'll convert the hex fingerprint to ArrayBuffer
-      // The fingerprint format is: "73:3d:c9:eb:f4:3a:04:ad:..."
-      // We need to convert this to raw bytes
-      
-      // Since we don't have the original fingerprint here, we'll decode the base58
-      // This is a simplified approach - in production, use a proper base58 decoder
-      const hexHash = this.base58ToHex(base58Data);
+      // The hash after uEi is already in hex format, just convert to bytes
       const bytes = new Uint8Array(hexHash.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)));
       
+      console.log('[WebTransport] Decoded certificate hash:', hexHash);
+      console.log('[WebTransport] Hash bytes length:', bytes.length);
+      
       return bytes.buffer;
     } catch (error) {
       console.error('[WebTransport] Failed to convert cert hash:', error);
-      // Fallback: create a dummy hash (this won't work but prevents crash)
-      return new Uint8Array(32).buffer;
-    }
-  }
-
-  /**
-   * Simple base58 to hex converter (simplified version)
-   */
-  private base58ToHex(base58: string): string {
-    // This is a simplified implementation
-    // In production, use a proper base58 decoding library
-    const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-    let num = BigInt(0);
-    
-    for (let i = 0; i < base58.length; i++) {
-      const char = base58[i];
-      const value = alphabet.indexOf(char);
-      if (value === -1) {
-        throw new Error(`Invalid base58 character: ${char}`);
-      }
-      num = num * BigInt(58) + BigInt(value);
+      throw new Error('Failed to decode certificate hash');
     }
-    
-    let hex = num.toString(16);
-    if (hex.length % 2) hex = '0' + hex;
-    
-    return hex;
   }
 }

package/src/types.ts

@@ -25,6 +25,10 @@ export interface PeerInfo {
   nodeUrl?: string;
   isRegistered?: boolean;
   owner?: string;
+  multiaddrs?: string[];
+  httpEndpoint?: string;
+  relayAddrs?: string[];
+  onChainNodeId?: string;
 }
 
 export interface StoreResult {