cPDA (Compressed Program Derived Accounts)

Loading diagram...

rust
pub struct CompressedCidPDA {
    pub cid_hash: [u8; 32],           // SHA256 of full CID
    pub file_size: u32,               // File size in bytes
    pub upload_timestamp: u32,        // Unix timestamp
    pub file_type: u8,                // File type enum
    pub access_permissions: u8,       // Permission flags
    pub retrieval_nodes: [u8; 4],     // Node addresses for retrieval
}

typescript
// Store a large video file with instant metadata access
const result = await windClient.uploadToCPDA({
  file: largeVideoFile,
  metadata: {
    title: "Conference Recording",
    duration: 3600,
    quality: "4K"
  }
});

// Query metadata in <100ms
const metadata = await windClient.queryCID(result.cid);

typescript
// Upload content to cPDA
const contentCID = await windClient.uploadContent(podcast);

// Users can instantly query if content exists
const exists = await contract.verifyCID(contentCID); // <100ms

// Retrieve full content when needed
const content = await windClient.retrieveFile(contentCID);

typescript
// Store legal documents with timestamp verification
const docResult = await windClient.uploadLegalDoc({
  document: contractPDF,
  attestation: digitalSignature,
  compliance: "SOX"
});

// Fast compliance checks
const isCompliant = await contract.checkCompliance(docResult.cid);

typescript
// Store research dataset
const datasetCID = await windClient.uploadDataset({
  data: largeBiologyDataset,
  metadata: {
    study: "Protein Analysis 2024",
    size: "50GB",
    format: "HDF5"
  }
});

// Researchers can quickly verify dataset existence
const verified = await contract.verifyDataset(datasetCID);

typescript
interface CPDAUploadOptions {
  file: File | Buffer;
  metadata?: Record<string, any>;
  permissions?: AccessPermissions;
  redundancy?: number; // Number of storage replicas
}

interface CPDAUploadResult {
  cid: string;
  pda: PublicKey;
  fileSize: number;
  uploadTimestamp: number;
  retrievalNodes: string[];
}

const result = await windClient.uploadToCPDA(options);

typescript
interface CIDQueryOptions {
  cid: string;
  includeMetadata?: boolean;
  verifyIntegrity?: boolean;
}

interface CIDQueryResult {
  exists: boolean;
  fileSize: number;
  uploadTimestamp: number;
  fileType: string;
  permissions: AccessPermissions;
  retrievalNodes: string[];
  metadata?: Record<string, any>;
}

const result = await windClient.queryCID(cid, options);

typescript
interface RetrievalOptions {
  cid: string;
  preferredNode?: string;
  timeout?: number;
  verifyIntegrity?: boolean;
}

const file = await windClient.retrieveFile(options);

rust
use wind_network_sdk::cPDA;

#[program]
pub mod my_program {
    pub fn verify_document(
        ctx: Context<VerifyDocument>,
        cid: String,
    ) -> Result<()> {
        // Query cPDA in <100ms
        let cid_info = cPDA::query_cid(&cid)?;
        
        require!(cid_info.exists, ErrorCode::DocumentNotFound);
        require!(cid_info.file_size > 0, ErrorCode::InvalidDocument);
        
        // Use the verified CID in your program logic
        ctx.accounts.document_registry.add_verified_document(cid)?;
        
        Ok(())
    }
}

typescript
import { WindClient, cPDA } from '@wind-network/sdk';

class DocumentManager {
  private windClient: WindClient;
  
  constructor() {
    this.windClient = new WindClient({
      endpoint: 'https://api.windnetwork.ai',
      cluster: 'mainnet-beta'
    });
  }
  
  async uploadDocument(file: File, metadata: any) {
    // Upload to cPDA
    const result = await this.windClient.uploadToCPDA({
      file,
      metadata,
      redundancy: 3 // Store on 3 nodes
    });
    
    // Store CID reference on-chain
    await this.storeOnChain(result.cid, result.pda);
    
    return result;
  }
  
  async verifyDocument(cid: string) {
    // Fast on-chain verification (<100ms)
    const exists = await this.windClient.queryCID(cid);
    return exists.exists && exists.fileSize > 0;
  }
  
  async retrieveDocument(cid: string) {
    // Retrieve full file from Lava Lakes
    return await this.windClient.retrieveFile({ cid });
  }
}

bash
npm install @wind-network/sdk
# or
yarn add @wind-network/sdk

typescript
import { WindClient } from '@wind-network/sdk';

const client = new WindClient({
  endpoint: 'http://test-may-us-01.windnetwork.ai:3000/api',
  cluster: 'devnet' // or 'mainnet-beta'
});

typescript
async function uploadExample() {
  // Upload a file to cPDA
  const file = new File(['Hello, cPDA!'], 'example.txt');
  
  const result = await client.uploadToCPDA({
    file,
    metadata: {
      description: 'My first cPDA upload',
      category: 'example'
    }
  });
  
  console.log('File uploaded with CID:', result.cid);
  console.log('PDA address:', result.pda.toString());
  
  // Query the CID (should be <100ms)
  const queryResult = await client.queryCID(result.cid);
  console.log('Query result:', queryResult);
  
  return result;
}

typescript
// Good: Store frequently queried metadata on-chain
const result = await client.uploadToCPDA({
  file: document,
  metadata: {
    title: doc.title,        // Frequently searched
    category: doc.category,  // Used for filtering
    timestamp: Date.now()    // Used for sorting
  }
});

// Query pattern
const docs = await client.queryMultipleCIDs({
  filter: { category: 'legal' },
  sortBy: 'timestamp',
  limit: 100
});

typescript
try {
  const result = await client.uploadToCPDA(options);
} catch (error) {
  if (error.code === 'STORAGE_FULL') {
    // Retry with different nodes
    await client.uploadToCPDA({
      ...options,
      preferredNodes: alternativeNodes
    });
  } else if (error.code === 'NETWORK_TIMEOUT') {
    // Implement exponential backoff
    await retryWithBackoff(() => client.uploadToCPDA(options));
  }
}

typescript
class CPDACache {
  private cache = new Map();
  
  async getCIDInfo(cid: string) {
    if (this.cache.has(cid)) {
      return this.cache.get(cid);
    }
    
    const info = await client.queryCID(cid);
    this.cache.set(cid, info);
    return info;
  }
}

typescript
const metrics = await client.getCPDAMetrics({
  timeRange: '24h',
  metrics: [
    'query_latency',
    'upload_success_rate',
    'retrieval_speed',
    'storage_utilization'
  ]
});

console.log('Average query latency:', metrics.query_latency.avg); // Should be <100ms
console.log('Upload success rate:', metrics.upload_success_rate); // Should be >99%

typescript
const health = await client.getSystemHealth();
console.log('Network status:', health.status);
console.log('Available storage:', health.storage.available);
console.log('Active nodes:', health.nodes.active);