Content-Addressable Store

On-chain:  [32-byte hash] ──references──> Off-chain: [100KB ciphertext]

use privora_sdk_program::prelude::*;

pub fn process(price_ref: EncryptedRef<u8>) -> ProgramResult {
    // Load fetches the ciphertext from the content store
    let price: Encrypted<u8> = price_ref.load()?;

    // Now we can perform operations
    let doubled = price.add(&price)?;

    Ok(())
}

// Perform computation
let result = a.add(&b)?;

// Store result and get hash reference
let result_ref: EncryptedRef<u8> = result.store()?;

// Save the hash to account data
account.result_ref = result_ref;

/// Fetch data from the content-addressable store.
///
/// # Arguments
/// * `hash` - 32-byte SHA256 hash of the data
///
/// # Returns
/// * `Ok(Vec<u8>)` - The ciphertext data
/// * `Err` - If data not found or fetch failed
pub fn fetch_data(hash: &[u8; 32]) -> Result<Vec<u8>, ProgramError>;

/// Submit data to the content-addressable store.
///
/// # Arguments
/// * `data` - The ciphertext bytes to store
///
/// # Returns
/// * `Ok([u8; 32])` - The SHA256 hash of the stored data
/// * `Err` - If submission failed
pub fn submit_data(data: &[u8]) -> Result<[u8; 32], ProgramError>;

#[derive(BorshSerialize, BorshDeserialize)]
pub struct MinimalAccount {
    pub owner: Pubkey,              // 32 bytes
    pub encrypted_balance: EncryptedRef<u64>,  // 32 bytes (not 80KB!)
}

#[derive(BorshSerialize, BorshDeserialize)]
pub struct OrderAccount {
    pub owner: Pubkey,              // 32 bytes
    pub price_ref: EncryptedRef<u8>,    // 32 bytes
    pub quantity_ref: EncryptedRef<u8>, // 32 bytes
    pub total_ref: EncryptedRef<u64>,   // 32 bytes
}
// Total: 128 bytes on-chain, referencing ~150KB of ciphertexts

// Good: Load once, compute, store once
let a = a_ref.load()?;
let b = b_ref.load()?;
let c = c_ref.load()?;

let result = a.add(&b)?.mul(&c)?;
let result_ref = result.store()?;

// Bad: Load repeatedly
let result = a_ref.load()?.add(&b_ref.load()?)?.mul(&c_ref.load()?)?;

use privora_sdk_client::prelude::*;

let privora = PrivoraClient::new("http://localhost:8899").await?;

// Encrypt and submit
let encrypted = privora.encryptor().encrypt(100u8)?;
let hash = privora.submit(&encrypted).await?;

// Use hash in transaction
let instruction_data = [&[0u8], hash.as_slice()].concat();

const privora = await Privora.connect('http://localhost:8899');

// Encrypt and submit
const encrypted = privora.encrypt(100, 'u8');
const hash = await privora.submit(encrypted);

// Use hash in transaction
const instructionData = Buffer.concat([
  Buffer.from([0]),
  Buffer.from(hash, 'hex'),
]);