storageService.js

// ============================================================
// 0G Storage Service — Upload/Download Memory Blobs
// ============================================================

import { NETWORK_CONFIG } from '../config/network';
import { onNetworkChange } from '../config/network';
// UPLOAD_OPTIONS is no longer used here — uploads moved server-side (see
// server/storageUpload.js) to get around the 0G indexer's missing CORS headers.
import { PROTOCOL_VERSION } from '../config/constants';
import { EMBEDDING_DIMENSIONS } from '../../shared/embeddingConfig.js';

const BACKEND_URL = import.meta.env.VITE_BACKEND_URL || '';

// Lazy-load the SDK to avoid polyfill issues at module init time
let _sdk = null;
async function getSDK() {
  if (!_sdk) {
    try {
      _sdk = await import('@0gfoundation/0g-ts-sdk/browser');
    } catch (e) {
      console.warn('[StorageService] Browser SDK import failed, trying main path:', e.message);
      try {
        _sdk = await import('@0gfoundation/0g-ts-sdk');
      } catch (e2) {
        console.error('[StorageService] SDK import failed entirely:', e2.message);
        throw new Error('0G SDK could not be loaded. Check polyfill configuration.');
      }
    }
  }
  return _sdk;
}

class StorageService {
  constructor() {
    this.indexer = null;
    this.logs = [];
    this.logListeners = new Set();

    // Reset indexer when network changes
    onNetworkChange(() => {
      this.indexer = null;
      this._emitLog('CONNECT', 'Network changed — indexer reset, will reconnect on next operation', 'info');
    });
  }

  // Subscribe to log events (for the Data Terminal)
  onLog(listener) {
    this.logListeners.add(listener);
    return () => this.logListeners.delete(listener);
  }

  _emitLog(type, message, status = 'info') {
    const log = {
      id: Date.now() + Math.random(),
      type,
      message,
      timestamp: new Date().toLocaleTimeString('en-US', {
        hour12: false,
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit',
        fractionalSecondDigits: 3,
      }),
      status,
    };
    this.logs.push(log);
    this.logListeners.forEach(fn => fn(log));
    return log;
  }

  // Initialize the Indexer client
  async _getIndexer() {
    if (!this.indexer) {
      const sdk = await getSDK();
      this.indexer = new sdk.Indexer(NETWORK_CONFIG.indexerRpc);
      this._emitLog('CONNECT', `0G Storage indexer connected  ❯  ${NETWORK_CONFIG.indexerRpc}`, 'success');
    }
    return this.indexer;
  }

  // ─── CORE: Store Memory Vector ───────────────────────────────

  // No signer parameter: the upload is signed server-side with the backend's
  // 0G key (see server/storageUpload.js), which exists because the 0G indexer
  // sends no CORS headers and the browser SDK cannot reach it directly. The
  // user's wallet still signs the on-chain anchor separately.
  async storeMemory(memoryData) {
    const startTime = performance.now();
    this._emitLog('STORE', `Preparing memory blob  ❯  agent: ${memoryData.agentId}  ❯  dim: ${memoryData.embedding?.dim ?? EMBEDDING_DIMENSIONS}  ❯  model: ${memoryData.embedding?.model?.id ?? 'none'}`, 'info');

    try {
      // 1. Serialize the memory object to JSON
      // v2 blob schema. 0G blobs are immutable and Merkle-anchored, so this
      // shape is a one-way door — every field here is permanent.
      //
      // The load-bearing addition is `embedding.source` + `embedding.model.id`.
      // v0.1.0 blobs recorded a bare vector and a `dimensions` integer, with
      // nothing distinguishing PRNG noise from a real model's output. That
      // ambiguity cannot be fixed retroactively; stamping provenance now means
      // this migration never has to happen a second time.
      //
      // The old `dimensions: embedding?.length || 1536` line is gone: with `||`
      // (not `??`) a missing OR empty embedding wrote a false 1536 into a
      // permanent record. A missing embedding is now simply `embedding: null`.
      const memoryPayload = {
        protocol: 'memoria-da',
        schema: 'memoria-da/memory',
        schemaVersion: 2,
        version: PROTOCOL_VERSION,
        type: 'memory',
        timestamp: new Date().toISOString(),
        agentId: memoryData.agentId,
        content: memoryData.content,
        // The vector is computed over exactly this `content` string, recorded
        // so retrieval semantics are provable from the blob alone.
        inputTransform: 'content',
        embedding: memoryData.embedding ?? null,
        metadata: {
          ...memoryData.metadata,
          framework: memoryData.metadata?.framework || 'OpenClaw',
        },
      };

      const jsonStr = JSON.stringify(memoryPayload);
      const nativeBlob = new Blob([jsonStr], { type: 'application/json' });
      const blobSize = nativeBlob.size;

      this._emitLog('VECTOR', `Embedding serialized  ❯  size: ${(blobSize / 1024).toFixed(1)} KB  ❯  segments: ${Math.ceil(blobSize / 256)}`, 'info');

      // 2–4. Upload via backend server (avoids browser CORS block on 0G Storage nodes)
      this._emitLog('UPLOAD', `Uploading to 0G Storage via backend  ❯  blob_size: ${(blobSize / 1024).toFixed(1)} KB  ❯  indexer: turbo`, 'info');

      const networkKey = NETWORK_CONFIG.key || 'testnet';
      const uploadRes = await fetch(`${BACKEND_URL}/api/storage/upload`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ payload: memoryPayload, network: networkKey }),
      });

      if (!uploadRes.ok) {
        const errData = await uploadRes.json().catch(() => ({ error: `HTTP ${uploadRes.status}` }));
        this._emitLog('ERROR', `Upload failed: ${errData.error}`, 'error');
        throw new Error(errData.error || `Storage upload failed (${uploadRes.status})`);
      }

      const { rootHash, tx, blobSize: serverBlobSize } = await uploadRes.json();

      this._emitLog('MERKLE', `Merkle root received  ❯  root: ${rootHash.slice(0, 10)}...${rootHash.slice(-6)}`, 'success');

      const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
      this._emitLog('CONFIRM', `✓ Memory committed to 0G Storage  ❯  root: ${rootHash.slice(0, 10)}...${rootHash.slice(-6)}  ❯  ${elapsed}s`, 'success');

      if (tx) {
        this._emitLog('TX', `Onchain tx confirmed  ❯  hash: ${typeof tx === 'string' ? tx.slice(0, 14) : '0x...'}`, 'success');
      }

      return {
        rootHash,
        blobSize: serverBlobSize || blobSize,
        tx,
        elapsed: parseFloat(elapsed),
      };
    } catch (error) {
      this._emitLog('ERROR', `Storage error: ${error.message}`, 'error');
      throw error;
    }
  }

  // ─── CORE: Retrieve Memory Vector ──────────────────────────────

  async retrieveMemory(rootHash) {
    const startTime = performance.now();
    this._emitLog('FETCH', `Fetching from 0G Storage  ❯  root: ${rootHash.slice(0, 10)}...${rootHash.slice(-6)}`, 'info');

    try {
      // Use the REST API endpoint for browser-compatible download
      const apiUrl = `${NETWORK_CONFIG.indexerRpc}/file?root=${rootHash}`;
      const response = await fetch(apiUrl);

      if (!response.ok) {
        const contentType = response.headers.get('content-type');
        if (contentType && contentType.includes('application/json')) {
          const errData = await response.json();
          throw new Error(errData.message || `Download failed (${response.status})`);
        }
        throw new Error(`Download failed with status ${response.status}`);
      }

      const fileData = await response.arrayBuffer();
      const decoder = new TextDecoder('utf-8');
      const jsonStr = decoder.decode(fileData);
      const memoryData = JSON.parse(jsonStr);

      const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
      this._emitLog('RETRIEVE', `Memory retrieved  ❯  dim: ${memoryData.dimensions || '?'}  ❯  size: ${(fileData.byteLength / 1024).toFixed(1)} KB  ❯  ${elapsed}s`, 'success');

      return memoryData;
    } catch (error) {
      this._emitLog('ERROR', `Retrieval error: ${error.message}`, 'error');
      throw error;
    }
  }

  // NOTE: generateMockEmbedding() and cosineSimilarity() were removed here.
  //
  // The first produced 1536-dim vectors from a seeded PRNG. Because the
  // vectors were statistically independent of the text, cosine similarity
  // was noise and semantic recall could never fire — the retrieval filter
  // required >0.3, which for random unit vectors in 1536 dims is over 11
  // standard deviations out. Embeddings now come from the backend model
  // (see server/embeddingService.js); there is deliberately no local
  // fallback, because a random vector is indistinguishable from a real one
  // once it is written into an immutable, Merkle-anchored 0G blob.
  //
  // The second was a duplicate cosine implementation whose null-handling
  // differed from the one in memoryStore. Two copies that can drift apart
  // is a latent bug; memoryStore._cosineSimilarity is now the only one.
}

export const storageService = new StorageService();
export default storageService;