@gethashd/bytecave-browser 1.0.36 → 1.0.38

package/dist/{chunk-6WXUCYSA.js → chunk-CIBPIU23.js}

@@ -5695,7 +5695,7 @@ var P2PProtocolClient = class {
   /**
    * Store a blob on a peer via P2P stream
    */
-  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain) {
+  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain, hashIdToken) {
     if (!this.node) {
       return { success: false, error: "P2P node not initialized" };
     }
@@ -5791,6 +5791,7 @@ var P2PProtocolClient = class {
           shouldVerifyOnChain: shouldVerifyOnChain ?? false,
           sender: authorization?.sender,
           timestamp: authorization?.timestamp || Date.now(),
+          hashIdToken,
           authorization
         };
         console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");
@@ -6132,6 +6133,7 @@ var StorageWebSocketClient = class {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };
     return new Promise((resolve, reject) => {
@@ -6491,8 +6493,9 @@ var ByteCaveClient = class {
    * @param data - Data to store
    * @param mimeType - MIME type (optional, defaults to 'application/octet-stream')
    * @param signer - Ethers signer for authorization (optional, but required for most nodes)
+   * @param hashIdToken - HashID NFT token ID (optional, for content attribution)
    */
-  async store(data, mimeType, signer) {
+  async store(data, mimeType, signer, hashIdToken) {
     const dataArray = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
     const MAX_FILE_SIZE = 5 * 1024 * 1024;
     if (dataArray.length > MAX_FILE_SIZE) {
@@ -6548,6 +6551,7 @@ Nonce: ${nonce}`;
         const result = await this.storageWsClient.store({
           data: dataArray,
           contentType: mimeType || "application/octet-stream",
+          hashIdToken,
           authorization: wsAuth,
           timeout: 3e4
         });
@@ -6585,8 +6589,9 @@ Nonce: ${nonce}`;
           dataArray,
           mimeType || "application/octet-stream",
           authorization,
-          false
+          false,
           // shouldVerifyOnChain - false for browser test storage
+          hashIdToken
         );
         if (result.success && result.cid) {
           console.log("[ByteCave] \u2713 P2P store successful:", result.cid);
@@ -7087,11 +7092,11 @@ function ByteCaveProvider({
       setError(err.message);
     }
   };
-  const store = async (data, mimeType, signer) => {
+  const store = async (data, mimeType, signer, hashIdToken) => {
     if (!globalClient) {
       return { success: false, error: "Client not initialized" };
     }
-    return globalClient.store(data, mimeType, signer);
+    return globalClient.store(data, mimeType, signer, hashIdToken);
   };
   const retrieve = async (cid) => {
     if (!globalClient) {

package/dist/client.d.ts

@@ -35,8 +35,9 @@ export declare class ByteCaveClient {
      * @param data - Data to store
      * @param mimeType - MIME type (optional, defaults to 'application/octet-stream')
      * @param signer - Ethers signer for authorization (optional, but required for most nodes)
+     * @param hashIdToken - HashID NFT token ID (optional, for content attribution)
      */
-    store(data: Uint8Array | ArrayBuffer, mimeType?: string, signer?: any): Promise<StoreResult>;
+    store(data: Uint8Array | ArrayBuffer, mimeType?: string, signer?: any, hashIdToken?: number): Promise<StoreResult>;
     /**
      * Retrieve ciphertext from a node via P2P only (no HTTP fallback)
      */

package/dist/index.cjs

@@ -5763,7 +5763,7 @@ var P2PProtocolClient = class {
   /**
    * Store a blob on a peer via P2P stream
    */
-  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain) {
+  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain, hashIdToken) {
     if (!this.node) {
       return { success: false, error: "P2P node not initialized" };
     }
@@ -5859,6 +5859,7 @@ var P2PProtocolClient = class {
           shouldVerifyOnChain: shouldVerifyOnChain ?? false,
           sender: authorization?.sender,
           timestamp: authorization?.timestamp || Date.now(),
+          hashIdToken,
           authorization
         };
         console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");
@@ -6185,6 +6186,7 @@ var StorageWebSocketClient = class {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };
     return new Promise((resolve, reject) => {
@@ -6544,8 +6546,9 @@ var ByteCaveClient = class {
    * @param data - Data to store
    * @param mimeType - MIME type (optional, defaults to 'application/octet-stream')
    * @param signer - Ethers signer for authorization (optional, but required for most nodes)
+   * @param hashIdToken - HashID NFT token ID (optional, for content attribution)
    */
-  async store(data, mimeType, signer) {
+  async store(data, mimeType, signer, hashIdToken) {
     const dataArray = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
     const MAX_FILE_SIZE = 5 * 1024 * 1024;
     if (dataArray.length > MAX_FILE_SIZE) {
@@ -6601,6 +6604,7 @@ Nonce: ${nonce}`;
         const result = await this.storageWsClient.store({
           data: dataArray,
           contentType: mimeType || "application/octet-stream",
+          hashIdToken,
           authorization: wsAuth,
           timeout: 3e4
         });
@@ -6638,8 +6642,9 @@ Nonce: ${nonce}`;
           dataArray,
           mimeType || "application/octet-stream",
           authorization,
-          false
+          false,
           // shouldVerifyOnChain - false for browser test storage
+          hashIdToken
         );
         if (result.success && result.cid) {
           console.log("[ByteCave] \u2713 P2P store successful:", result.cid);
@@ -7140,11 +7145,11 @@ function ByteCaveProvider({
       setError(err.message);
     }
   };
-  const store = async (data, mimeType, signer) => {
+  const store = async (data, mimeType, signer, hashIdToken) => {
     if (!globalClient) {
       return { success: false, error: "Client not initialized" };
     }
-    return globalClient.store(data, mimeType, signer);
+    return globalClient.store(data, mimeType, signer, hashIdToken);
   };
   const retrieve = async (cid) => {
     if (!globalClient) {

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-6WXUCYSA.js";
+} from "./chunk-CIBPIU23.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/p2p-protocols.d.ts

@@ -65,6 +65,7 @@ export interface StoreRequest {
     shouldVerifyOnChain?: boolean;
     sender?: string;
     timestamp?: number;
+    hashIdToken?: number;
     metadata?: Record<string, any>;
     authorization?: any;
 }
@@ -82,7 +83,7 @@ export declare class P2PProtocolClient {
     /**
      * Store a blob on a peer via P2P stream
      */
-    storeToPeer(peerId: string, ciphertext: Uint8Array, mimeType: string, authorization?: any, shouldVerifyOnChain?: boolean): Promise<StoreResponse>;
+    storeToPeer(peerId: string, ciphertext: Uint8Array, mimeType: string, authorization?: any, shouldVerifyOnChain?: boolean, hashIdToken?: number): Promise<StoreResponse>;
     /**
      * Retrieve a blob from a peer via P2P stream
      */

package/dist/provider.d.ts

@@ -35,7 +35,7 @@ interface ByteCaveContextValue {
     appId: string;
     connect: () => Promise<void>;
     disconnect: () => Promise<void>;
-    store: (data: Uint8Array, mimeType?: string, signer?: any) => Promise<StoreResult>;
+    store: (data: Uint8Array, mimeType?: string, signer?: any, hashIdToken?: number) => Promise<StoreResult>;
     retrieve: (cid: string) => Promise<RetrieveResult>;
     registerContent: (cid: string, appId: string, hashIdToken: string, signer: any) => Promise<{
         success: boolean;

package/dist/react/index.cjs

@@ -6018,7 +6018,7 @@ var P2PProtocolClient = class {
   /**
    * Store a blob on a peer via P2P stream
    */
-  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain) {
+  async storeToPeer(peerId, ciphertext, mimeType, authorization, shouldVerifyOnChain, hashIdToken) {
     if (!this.node) {
       return { success: false, error: "P2P node not initialized" };
     }
@@ -6114,6 +6114,7 @@ var P2PProtocolClient = class {
           shouldVerifyOnChain: shouldVerifyOnChain ?? false,
           sender: authorization?.sender,
           timestamp: authorization?.timestamp || Date.now(),
+          hashIdToken,
           authorization
         };
         console.log("[ByteCave P2P] Step 5: Request prepared, size:", JSON.stringify(request).length, "bytes");

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-6WXUCYSA.js";
+} from "../chunk-CIBPIU23.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/dist/storage-websocket.d.ts

@@ -5,6 +5,7 @@
 export interface StoreViaWebSocketOptions {
     data: Uint8Array;
     contentType: string;
+    hashIdToken?: number;
     authorization?: {
         signature: string;
         address: string;

package/package.json

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

package/src/client.ts

@@ -423,8 +423,9 @@ export class ByteCaveClient {
    * @param data - Data to store
    * @param mimeType - MIME type (optional, defaults to 'application/octet-stream')
    * @param signer - Ethers signer for authorization (optional, but required for most nodes)
+   * @param hashIdToken - HashID NFT token ID (optional, for content attribution)
    */
-  async store(data: Uint8Array | ArrayBuffer, mimeType?: string, signer?: any): Promise<StoreResult> {
+  async store(data: Uint8Array | ArrayBuffer, mimeType?: string, signer?: any, hashIdToken?: number): Promise<StoreResult> {
     const dataArray = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
 
     // Validate file size (5MB limit)
@@ -496,6 +497,7 @@ Nonce: ${nonce}`;
         const result = await this.storageWsClient.store({
           data: dataArray,
           contentType: mimeType || 'application/octet-stream',
+          hashIdToken,
           authorization: wsAuth,
           timeout: 30000
         });
@@ -551,7 +553,8 @@ Nonce: ${nonce}`;
           dataArray,
           mimeType || 'application/octet-stream',
           authorization,
-          false // shouldVerifyOnChain - false for browser test storage
+          false, // shouldVerifyOnChain - false for browser test storage
+          hashIdToken
         );
 
         if (result.success && result.cid) {

package/src/p2p-protocols.ts

@@ -78,6 +78,7 @@ export interface StoreRequest {
   shouldVerifyOnChain?: boolean;
   sender?: string;
   timestamp?: number;
+  hashIdToken?: number;
   metadata?: Record<string, any>;
   authorization?: any;
 }
@@ -106,7 +107,8 @@ export class P2PProtocolClient {
     ciphertext: Uint8Array,
     mimeType: string,
     authorization?: any,
-    shouldVerifyOnChain?: boolean
+    shouldVerifyOnChain?: boolean,
+    hashIdToken?: number
   ): Promise<StoreResponse> {
     if (!this.node) {
       return { success: false, error: 'P2P node not initialized' };
@@ -227,6 +229,7 @@ export class P2PProtocolClient {
           shouldVerifyOnChain: shouldVerifyOnChain ?? false,
           sender: authorization?.sender,
           timestamp: authorization?.timestamp || Date.now(),
+          hashIdToken,
           authorization
         };
         console.log('[ByteCave P2P] Step 5: Request prepared, size:', JSON.stringify(request).length, 'bytes');

package/src/provider.tsx

@@ -39,7 +39,7 @@ interface ByteCaveContextValue {
   appId: string;
   connect: () => Promise<void>;
   disconnect: () => Promise<void>;
-  store: (data: Uint8Array, mimeType?: string, signer?: any) => Promise<StoreResult>;
+  store: (data: Uint8Array, mimeType?: string, signer?: any, hashIdToken?: number) => Promise<StoreResult>;
   retrieve: (cid: string) => Promise<RetrieveResult>;
   registerContent: (cid: string, appId: string, hashIdToken: string, signer: any) => Promise<{ success: boolean; txHash?: string; error?: string }>;
   getNodeHealth: (peerId: string) => Promise<NodeHealth | null>;
@@ -224,11 +224,11 @@ export function ByteCaveProvider({
     }
   };
 
-  const store = async (data: Uint8Array, mimeType?: string, signer?: any): Promise<StoreResult> => {
+  const store = async (data: Uint8Array, mimeType?: string, signer?: any, hashIdToken?: number): Promise<StoreResult> => {
     if (!globalClient) {
       return { success: false, error: 'Client not initialized' };
     }
-    return (globalClient as any).store(data, mimeType, signer);
+    return (globalClient as any).store(data, mimeType, signer, hashIdToken);
   };
 
   const retrieve = async (cid: string): Promise<RetrieveResult> => {

package/src/storage-websocket.ts

@@ -8,6 +8,7 @@ interface StorageRequestMessage {
   requestId: string;
   data: string; // base64
   contentType: string;
+  hashIdToken?: number;
   authorization?: {
     signature: string;
     address: string;
@@ -31,6 +32,7 @@ type Message = StorageRequestMessage | StorageResponseMessage;
 export interface StoreViaWebSocketOptions {
   data: Uint8Array;
   contentType: string;
+  hashIdToken?: number;
   authorization?: {
     signature: string;
     address: string;
@@ -124,6 +126,7 @@ export class StorageWebSocketClient {
       requestId,
       data: base64Data,
       contentType: options.contentType,
+      hashIdToken: options.hashIdToken,
       authorization: options.authorization
     };