@gethashd/bytecave-browser 1.0.35 → 1.0.37

package/dist/{chunk-PMRP2UEN.js → chunk-544OXLKK.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");
@@ -6168,8 +6169,8 @@ var StorageWebSocketClient = class {
 
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
-  "function registerContent(bytes32 cid, address owner, bytes32 appId) external",
-  "function registerContent(string cid, string appId) external",
+  "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
+  "function registerContent(string cid, string appId, uint256 hashIdToken) external",
   "function isContentRegistered(bytes32 cid) external view returns (bool)",
   "function getContentRecord(bytes32 cid) external view returns (tuple(address owner, bytes32 appId, uint256 timestamp))"
 ];
@@ -6491,8 +6492,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) {
@@ -6585,8 +6587,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);
@@ -6659,7 +6662,7 @@ Nonce: ${nonce}`;
    * Register content in ContentRegistry contract (on-chain)
    * This must be called before storing content that requires on-chain verification
    */
-  async registerContent(cid, appId, signer) {
+  async registerContent(cid, appId, hashIdToken, signer) {
     if (!this.config.contentRegistryAddress) {
       return {
         success: false,
@@ -6679,7 +6682,7 @@ Nonce: ${nonce}`;
         CONTENT_REGISTRY_ABI,
         signer
       );
-      const tx = await contract.registerContent(cid, appId);
+      const tx = await contract.registerContent(cid, appId, hashIdToken);
       console.log("[ByteCave] ContentRegistry transaction sent:", tx.hash);
       const receipt = await tx.wait();
       console.log("[ByteCave] ContentRegistry registration confirmed:", receipt.hash);
@@ -7087,11 +7090,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) {
@@ -7105,11 +7108,11 @@ function ByteCaveProvider({
     }
     return globalClient.getNodeHealth(peerId);
   };
-  const registerContent = async (cid, appId2, signer) => {
+  const registerContent = async (cid, appId2, hashIdToken, signer) => {
     if (!globalClient) {
       return { success: false, error: "Client not initialized" };
     }
-    return globalClient.registerContent(cid, appId2, signer);
+    return globalClient.registerContent(cid, appId2, hashIdToken, signer);
   };
   const value = {
     connectionState,

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)
      */
@@ -45,7 +46,7 @@ export declare class ByteCaveClient {
      * Register content in ContentRegistry contract (on-chain)
      * This must be called before storing content that requires on-chain verification
      */
-    registerContent(cid: string, appId: string, signer: ethers.Signer): Promise<{
+    registerContent(cid: string, appId: string, hashIdToken: string, signer: ethers.Signer): Promise<{
         success: boolean;
         txHash?: string;
         error?: string;

package/dist/contracts/ContentRegistry.d.ts

@@ -1 +1 @@
-export declare const CONTENT_REGISTRY_ABI: readonly ["function registerContent(bytes32 cid, address owner, bytes32 appId) external", "function registerContent(string cid, string appId) external", "function isContentRegistered(bytes32 cid) external view returns (bool)", "function getContentRecord(bytes32 cid) external view returns (tuple(address owner, bytes32 appId, uint256 timestamp))"];
+export declare const CONTENT_REGISTRY_ABI: readonly ["function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external", "function registerContent(string cid, string appId, uint256 hashIdToken) external", "function isContentRegistered(bytes32 cid) external view returns (bool)", "function getContentRecord(bytes32 cid) external view returns (tuple(address owner, bytes32 appId, uint256 timestamp))"];

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");
@@ -6221,8 +6222,8 @@ var StorageWebSocketClient = class {
 
 // src/contracts/ContentRegistry.ts
 var CONTENT_REGISTRY_ABI = [
-  "function registerContent(bytes32 cid, address owner, bytes32 appId) external",
-  "function registerContent(string cid, string appId) external",
+  "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
+  "function registerContent(string cid, string appId, uint256 hashIdToken) external",
   "function isContentRegistered(bytes32 cid) external view returns (bool)",
   "function getContentRecord(bytes32 cid) external view returns (tuple(address owner, bytes32 appId, uint256 timestamp))"
 ];
@@ -6544,8 +6545,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) {
@@ -6638,8 +6640,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);
@@ -6712,7 +6715,7 @@ Nonce: ${nonce}`;
    * Register content in ContentRegistry contract (on-chain)
    * This must be called before storing content that requires on-chain verification
    */
-  async registerContent(cid, appId, signer) {
+  async registerContent(cid, appId, hashIdToken, signer) {
     if (!this.config.contentRegistryAddress) {
       return {
         success: false,
@@ -6732,7 +6735,7 @@ Nonce: ${nonce}`;
         CONTENT_REGISTRY_ABI,
         signer
       );
-      const tx = await contract.registerContent(cid, appId);
+      const tx = await contract.registerContent(cid, appId, hashIdToken);
       console.log("[ByteCave] ContentRegistry transaction sent:", tx.hash);
       const receipt = await tx.wait();
       console.log("[ByteCave] ContentRegistry registration confirmed:", receipt.hash);
@@ -7140,11 +7143,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) {
@@ -7158,11 +7161,11 @@ function ByteCaveProvider({
     }
     return globalClient.getNodeHealth(peerId);
   };
-  const registerContent = async (cid, appId2, signer) => {
+  const registerContent = async (cid, appId2, hashIdToken, signer) => {
     if (!globalClient) {
       return { success: false, error: "Client not initialized" };
     }
-    return globalClient.registerContent(cid, appId2, signer);
+    return globalClient.registerContent(cid, appId2, hashIdToken, signer);
   };
   const value = {
     connectionState,

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-PMRP2UEN.js";
+} from "./chunk-544OXLKK.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,9 +35,9 @@ 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, signer: any) => Promise<{
+    registerContent: (cid: string, appId: string, hashIdToken: string, signer: any) => Promise<{
         success: boolean;
         txHash?: string;
         error?: string;

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-PMRP2UEN.js";
+} from "../chunk-544OXLKK.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "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)
@@ -551,7 +552,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) {
@@ -647,6 +649,7 @@ Nonce: ${nonce}`;
   async registerContent(
     cid: string,
     appId: string,
+    hashIdToken: string,
     signer: ethers.Signer
   ): Promise<{ success: boolean; txHash?: string; error?: string }> {
     if (!this.config.contentRegistryAddress) {
@@ -672,7 +675,7 @@ Nonce: ${nonce}`;
         signer
       );
 
-      const tx = await contract.registerContent(cid, appId);
+      const tx = await contract.registerContent(cid, appId, hashIdToken);
       console.log('[ByteCave] ContentRegistry transaction sent:', tx.hash);
 
       const receipt = await tx.wait();

package/src/contracts/ContentRegistry.ts

@@ -1,6 +1,6 @@
 export const CONTENT_REGISTRY_ABI = [
-  "function registerContent(bytes32 cid, address owner, bytes32 appId) external",
-  "function registerContent(string cid, string appId) external",
+  "function registerContent(bytes32 cid, address owner, bytes32 appId, uint256 hashIdToken) external",
+  "function registerContent(string cid, string appId, uint256 hashIdToken) external",
   "function isContentRegistered(bytes32 cid) external view returns (bool)",
   "function getContentRecord(bytes32 cid) external view returns (tuple(address owner, bytes32 appId, uint256 timestamp))"
 ] as const;

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,9 +39,9 @@ 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, signer: any) => Promise<{ success: boolean; txHash?: string; error?: string }>;
+  registerContent: (cid: string, appId: string, hashIdToken: string, signer: any) => Promise<{ success: boolean; txHash?: string; error?: string }>;
   getNodeHealth: (peerId: string) => Promise<NodeHealth | null>;
   error: string | 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> => {
@@ -245,11 +245,11 @@ export function ByteCaveProvider({
     return (globalClient as any).getNodeHealth(peerId);
   };
 
-  const registerContent = async (cid: string, appId: string, signer: any): Promise<{ success: boolean; txHash?: string; error?: string }> => {
+  const registerContent = async (cid: string, appId: string, hashIdToken: string, signer: any): Promise<{ success: boolean; txHash?: string; error?: string }> => {
     if (!globalClient) {
       return { success: false, error: 'Client not initialized' };
     }
-    return globalClient.registerContent(cid, appId, signer);
+    return globalClient.registerContent(cid, appId, hashIdToken, signer);
   };
 
   const value: ByteCaveContextValue = {