interface VerificationResult {
  verified: boolean;         // Overall verification status
  onChainRoot: string;       // Merkle root from Solana
  localRoot: string;         // Computed Merkle root from local vectors
  match: boolean;            // Whether roots match
  vectorCount: number;       // Number of vectors verified
  solanaExplorerUrl: string; // Link to view proof on Solana Explorer
  timestamp: number;         // Verification timestamp (ms)
}

         Root Hash (on-chain)
            /        \
          H(AB)      H(CD)
          /  \        /  \
        H(A) H(B)  H(C) H(D)
         |    |     |    |
       vec_1 vec_2 vec_3 vec_4

const result = await col.verify();
console.log(result.solanaExplorerUrl);
// https://explorer.solana.com/address/8iLpyegDt8Vx2Q56kdvDJYpmnkTD2VDZvHXXead75Fm7?cluster=devnet

const result = await col.verify();

if (!result.match) {
  console.error('VERIFICATION FAILED!');
  console.error('Local root:', result.localRoot);
  console.error('On-chain root:', result.onChainRoot);
  console.error('Vector count:', result.vectorCount);
  
  // Possible causes:
  // 1. Local data was modified
  // 2. On-chain update failed
  // 3. Using wrong wallet/network
}

const sv = new SolVec({ network: 'devnet' }); // No wallet
const col = sv.collection('test', { dimensions: 1536 });

const result = await col.verify();
console.log(result.onChainRoot); // 'wallet-required'
console.log(result.verified);    // false

import { SolVec } from 'solvec';

const sv = new SolVec({ 
  network: 'mainnet-beta',
  walletPath: process.env.WALLET_PATH
});

const col = sv.collection('production-vectors', { dimensions: 1536 });

// 1. Upsert vectors
await col.upsert(vectors);

// 2. Verify immediately
const result = await col.verify();

if (!result.match) {
  throw new Error('Verification failed! Data integrity compromised.');
}

// 3. Log proof URL
console.log('Verified on Solana:', result.solanaExplorerUrl);

// 4. Continue with queries
const matches = await col.query({ vector: [...], topK: 5 });

import { SolVec } from 'solvec';
import { Connection, PublicKey } from '@solana/web3.js';

// 1. Connect to Solana
const connection = new Connection('https://api.mainnet-beta.solana.com');

// 2. Fetch on-chain data
const collectionPDA = new PublicKey('8iLpyegDt8Vx2Q56kdvDJYpmnkTD2VDZvHXXead75Fm7');
const accountInfo = await connection.getAccountInfo(collectionPDA);

// 3. Parse Merkle root
const onChainRoot = parseCollectionData(accountInfo.data);

// 4. Download vector IDs from Shadow Drive
const vectorIds = await fetchVectorIds(collectionPDA);

// 5. Compute local Merkle root
const localRoot = computeMerkleRoot(vectorIds);

// 6. Compare
if (localRoot === onChainRoot) {
  console.log('✓ Collection verified!');
} else {
  console.error('✗ Verification failed!');
}

// ❌ BAD: 100 on-chain updates
for (const vec of vectors) {
  await col.upsert([vec]); // Updates Merkle root each time
}

// ✅ GOOD: 1 on-chain update
await col.upsert(vectors); // Updates Merkle root once

import cron from 'node-cron';

// Verify integrity every hour
cron.schedule('0 * * * *', async () => {
  const result = await col.verify();
  
  if (!result.match) {
    // Alert admin
    await sendAlert({
      severity: 'critical',
      message: 'Vector database verification failed',
      explorerUrl: result.solanaExplorerUrl
    });
  } else {
    console.log(`✓ Verified ${result.vectorCount} vectors`);
  }
});

app.get('/health/vectors', async (req, res) => {
  const result = await col.verify();
  
  res.json({
    status: result.match ? 'healthy' : 'unhealthy',
    verified: result.verified,
    vectorCount: result.vectorCount,
    merkleRoot: result.onChainRoot,
    explorerUrl: result.solanaExplorerUrl,
    lastChecked: new Date().toISOString()
  });
});

use solvec_core::merkle::MerkleTree;

let vector_ids = vec!["vec_1".to_string(), "vec_2".to_string(), "vec_3".to_string()];
let tree = MerkleTree::new(&vector_ids);

// Generate proof for a specific vector
if let Some(proof) = tree.generate_proof("vec_2") {
    // Proof contains sibling hashes needed for verification
    let is_valid = proof.verify("vec_2", tree.root());
    println!("Proof valid: {}", is_valid);
}