@pod-protocol/sdk/dist/services/ipfs.d.ts

TypeScript SDK for PoD Protocol - AI agent communication on Solana

import { BaseService } from "./base.js";
import { CID } from 'multiformats/cid';
/**
 * IPFS configuration options
 */
export interface IPFSConfig {
    /** Disable IPFS functionality completely */
    disabled?: boolean;
    /** Custom Helia node configuration */
    heliaConfig?: any;
    /** Timeout for IPFS operations in milliseconds */
    timeout?: number;
    /** Gateway URL for retrieving content */
    gatewayUrl?: string;
}
/**
 * Channel message content structure for IPFS storage
 */
export interface ChannelMessageContent {
    content: string;
    attachments?: string[];
    metadata?: Record<string, any>;
    timestamp: number;
    version: string;
}
/**
 * Participant extended metadata structure for IPFS storage
 */
export interface ParticipantExtendedMetadata {
    displayName?: string;
    avatar?: string;
    permissions?: string[];
    customData?: Record<string, any>;
    lastUpdated: number;
}
/**
 * IPFS storage result
 */
export interface IPFSStorageResult {
    hash: string;
    cid: CID;
    size: number;
    url: string;
}
/**
 * IPFS Service for handling off-chain storage of PoD Protocol data
 * Integrates with ZK compression for cost-effective data management
 * Uses Helia (modern IPFS implementation) instead of deprecated js-IPFS
 */
export declare class IPFSService extends BaseService {
    private helia;
    private fs;
    private jsonStore;
    private config;
    private initPromise;
    constructor(rpcUrl: string, programId: string, commitment: any, config?: IPFSConfig);
    /**
     * Initialize Helia node and services
     */
    private init;
    /**
     * Ensure Helia is initialized
     */
    private ensureIPFSInitialized;
    /**
     * Store channel message content on IPFS
     */
    storeMessageContent(content: string, attachments?: string[], metadata?: Record<string, any>): Promise<IPFSStorageResult>;
    /**
     * Store participant extended metadata on IPFS
     */
    storeParticipantMetadata(displayName: string, avatar?: string, permissions?: string[], customData?: Record<string, any>): Promise<IPFSStorageResult>;
    /**
     * Store arbitrary JSON data on IPFS
     */
    storeJSON(data: any): Promise<IPFSStorageResult>;
    /**
     * Store raw file data on IPFS
     */
    storeFile(data: Buffer | Uint8Array, filename?: string): Promise<IPFSStorageResult>;
    /**
     * Retrieve JSON data from IPFS
     */
    retrieveJSON<T = any>(hash: string): Promise<T>;
    /**
     * Retrieve message content from IPFS
     */
    retrieveMessageContent(hash: string): Promise<ChannelMessageContent>;
    /**
     * Retrieve participant metadata from IPFS
     */
    retrieveParticipantMetadata(hash: string): Promise<ParticipantExtendedMetadata>;
    /**
     * Retrieve raw file data from IPFS
     */
    retrieveFile(hash: string): Promise<Buffer>;
    /**
     * Pin content to ensure it stays available
     */
    pinContent(hash: string): Promise<void>;
    /**
     * Unpin content to allow garbage collection
     */
    unpinContent(hash: string): Promise<void>;
    /**
     * Get IPFS node info
     */
    getNodeInfo(): Promise<any>;
    /**
     * Check if content exists on IPFS
     */
    contentExists(hash: string): Promise<boolean>;
    /**
     * Store channel message content on IPFS
     */
    storeChannelMessageContent(content: ChannelMessageContent): Promise<IPFSStorageResult>;
    /**
     * Store participant extended metadata on IPFS
     */
    storeParticipantExtendedMetadata(metadata: ParticipantExtendedMetadata): Promise<IPFSStorageResult>;
    /**
     * Retrieve channel message content from IPFS
     */
    retrieveChannelMessageContent(hash: string): Promise<ChannelMessageContent>;
    /**
     * Retrieve participant extended metadata from IPFS
     */
    retrieveParticipantExtendedMetadata(hash: string): Promise<ParticipantExtendedMetadata>;
    /**
     * Cleanup resources
     */
    stop(): Promise<void>;
    /**
     * Create a content hash for verification
     * Matches the Rust program's hash_to_bn254_field_size_be function
     */
    static createContentHash(content: string): string;
    /**
     * Create a metadata hash for participant data
     * Matches the Rust program's metadata hashing
     */
    static createMetadataHash(metadata: ParticipantExtendedMetadata): string;
    /**
     * Batch store multiple content items
     */
    batchStore(items: Array<{
        content: any;
        filename?: string;
    }>): Promise<IPFSStorageResult[]>;
    /**
     * Get gateway URL for content
     */
    getGatewayUrl(hash: string, gateway?: string): string;
    /**
     * Validate IPFS hash format
     */
    static isValidIPFSHash(hash: string): boolean;
    /**
     * Get content from IPFS (wrapper for retrieveJSON)
     * @param hash IPFS hash to retrieve
     * @returns Content data
     */
    getContent(hash: string): Promise<any>;
    /**
     * Create a hash for content (wrapper for createContentHash)
     * @param content Content to hash
     * @returns Hash string
     */
    createHash(content: string): string;
    /**
     * Get IPFS service information
     * @returns Service information
     */
    getInfo(): Promise<{
        version: string;
        status: string;
        nodes: number;
        storage: {
            used: number;
            available: number;
        };
    }>;
}
//# sourceMappingURL=ipfs.d.ts.map