Decentralized Storage Solutions: Complete Guide 2026

// Using IPFS with JavaScript
const IPFS = require('ipfs-http-client');

const ipfs = IPFS.create({ 
    host: 'ipfs.infura.io', 
    port: 5001, 
    protocol: 'https' 
});

// Upload file to IPFS
async function uploadToIPFS(fileBuffer) {
    const { path } = await ipfs.add(fileBuffer);
    console.log('IPFS CID:', path);
    return path; // Returns Content Identifier (CID)
}

// Upload with options
async function uploadWithOptions(fileBuffer, fileName) {
    const { path } = await ipfs.add({
        path: fileName,
        content: fileBuffer
    }, {
        pin: true, // Keep the file pinned
        wrapWithDirectory: true
    });
    return path;
}

// Retrieve file from IPFS
async function downloadFromIPFS(cid) {
    for await (const chunk of ipfs.cat(cid)) {
        process.stdout.write(chunk);
    }
}

// Get file info
async function getFileInfo(cid) {
    const stat = await ipfs.files.stat(`/ipfs/${cid}`);
    console.log('Size:', stat.size);
    console.log('Cumulative size:', stat.cumulativeSize);
    console.log('Type:', stat.type);
}

// Using Filecoin with Lotus SDK
const { Lotus } = require('filecoin-lotus-client');

const client = new Lotus('https://api.node.glif.io/rpc/v0');

// Deal parameters
const dealParams = {
    miner: 'f01234',           // Storage provider address
    data: 'Qm...',             // CID of data to store
    price: '0.00005',          // FIL per GiB per epoch
    duration: 518400,          // Deal duration in epochs (approx 180 days)
    startEpoch: 0,             // When deal starts
};

// Make storage deal
async function makeDeal(dataCID) {
    const deal = await client.client.deal(dataCID, dealParams);
    console.log('Deal ID:', deal['DealID']);
    return deal;
}

// Check deal status
async function checkDeal(dealId) {
    const status = await client.client.getDealStatus(dealId);
    console.log('Deal Status:', status);
}

// Retrieve data
async function retrieveData(dealId) {
    const data = await client.client.retrieve({
        dealId: dealId,
        carExport: false
    });
    return data;
}

// Using Arweave with arweave-js
const Arweave = require('arweave');

// Initialize Arweave
const arweave = Arweave.init({
    host: 'arweave.net',
    port: 443,
    protocol: 'https'
});

// Upload data (transaction)
async function uploadToArweave(data, tags = []) {
    // Create transaction
    const transaction = await arweave.createTransaction({
        data: data
    });
    
    // Add tags for metadata
    transaction.addTag('App-Name', 'MyDApp');
    transaction.addTag('Content-Type', 'application/json');
    transaction.addTag('Timestamp', Date.now().toString());
    
    // Sign and post
    await arweave.transactions.sign(transaction, wallet);
    const response = await arweave.transactions.post(transaction);
    
    console.log('Transaction ID:', transaction.id);
    return transaction.id;
}

// Upload with JWK (wallet)
async function uploadWithWallet(jwk, data) {
    const transaction = await arweave.createTransaction({
        data: data,
        key: jwk
    });
    
    await arweave.transactions.sign(transaction, jwk);
    await arweave.transactions.post(transaction);
    
    return transaction.id;
}

// Retrieve data
async function downloadFromArweave(transactionId) {
    const data = await arweave.transactions.getData(transactionId, {
        decode: true,
        string: true
    });
    return data;
}

// Query with GraphQL
async function queryArweave() {
    const query = `
        query {
            transactions(
                tags: { name: "App-Name", values: ["MyDApp"] }
                first: 10
            ) {
                edges {
                    node {
                        id
                        tags {
                            name
                            value
                        }
                    }
                }
            }
        }
    `;
    
    const result = await arweave.api.post('/graphql', { query });
    return result.data.data.transactions;
}

// Multi-provider storage abstraction
class DecentralizedStorage {
    constructor(config) {
        this.ipfs = config.ipfs;
        this.filecoin = config.filecoin;
        this.arweave = config.arweave;
        this.backup = config.backup; // Traditional backup
    }
    
    async upload(data, options = {}) {
        const results = [];
        
        // Upload to primary provider
        if (options.primary === 'ipfs') {
            const ipfsResult = await this.uploadToIPFS(data);
            results.push({ provider: 'ipfs', cid: ipfsResult });
            
            // Pin for persistence
            await this.pinIPFS(ipfsResult);
        }
        
        // Redundant upload to secondary
        if (options.redundant) {
            if (options.primary !== 'arweave') {
                const arweaveResult = await this.uploadToArweave(data);
                results.push({ provider: 'arweave', cid: arweaveResult });
            }
            
            if (options.primary !== 'filecoin') {
                const filecoinResult = await this.uploadToFilecoin(data);
                results.push({ provider: 'filecoin', cid: filecoinResult });
            }
        }
        
        return {
            primary: results[0],
            mirrors: results.slice(1),
            timestamp: Date.now()
        };
    }
    
    async retrieve(cids) {
        // Try each provider until successful
        for (const cid of cids) {
            try {
                const data = await this.tryProvider(cid);
                return data;
            } catch (e) {
                console.log(`Failed to retrieve from ${cid.provider}`);
                continue;
            }
        }
        throw new Error('All retrieval attempts failed');
    }
}

// Store NFT metadata on IPFS with Arweave backup
class NFTMetadataStorage {
    constructor(ipfs, arweave) {
        this.ipfs = ipfs;
        this.arweave = arweave;
    }
    
    async uploadMetadata(metadata) {
        // Create metadata object
        const nftMetadata = {
            name: metadata.name,
            description: metadata.description,
            image: metadata.image, // IPFS CID
            attributes: metadata.attributes,
            external_url: metadata.external_url,
            created_at: new Date().toISOString()
        };
        
        // Upload to IPFS
        const ipfsCid = await this.uploadToIPFS(JSON.stringify(nftMetadata));
        
        // Backup to Arweave
        const arweaveId = await this.uploadToArweave(JSON.stringify(nftMetadata));
        
        return {
            ipfs: `ipfs://${ipfsCid}`,
            arweave: `arweave://${arweaveId}`,
            combined: `ipfs://${ipfsCid}?ARWEAVE=${arweaveId}`
        };
    }
    
    // Example metadata structure
    async createExampleNFT(name, imageUrl, attributes) {
        // First upload image
        const imageCid = await this.uploadImageToIPFS(imageUrl);
        
        // Create full metadata
        const metadata = {
            name: name,
            description: `A unique digital collectible - ${name}`,
            image: `ipfs://${imageCid}`,
            attributes: attributes,
            compiler: "NFT Builder 2026"
        };
        
        return this.uploadMetadata(metadata);
    }
}

class StorageCostCalculator:
    """Compare storage costs across providers"""
    
    # Average prices (2026 estimates)
    PRICES = {
        "aws_s3": {
            "storage": 0.023,  # per GB/month
            "egress": 0.09,    # per GB
            "requests": 0.0004  # per 1k requests
        },
        "ipfs": {
            "storage": 0.0,    # free (self-hosted)
            "pinning": 0.01,   # per GB/month (Pinata)
            "egress": 0.0      # free
        },
        "filecoin": {
            "storage": 0.005,  # per GB/month
            "retrieval": 0.0001,
            "egress": 0.0
        },
        "arweave": {
            "storage": 8.0,    # one-time per GB
            "retrieval": 0.0,
            "projection_10yr": 0.80  # amortized over 10 years
        }
    }
    
    def calculate_annual_cost(self, provider, gb_stored, gb_transferred, requests):
        """Calculate annual storage costs"""
        prices = self.PRICES[provider]
        
        if provider == "arweave":
            # One-time cost amortized
            storage_cost = gb_stored * prices["storage"] / 10
        else:
            storage_cost = gb_stored * prices["storage"]
        
        egress_cost = gb_transferred * prices.get("egress", 0)
        request_cost = requests * prices.get("requests", 0) / 1000
        
        return storage_cost + egress_cost + request_cost
    
    def compare_providers(self, gb_stored, gb_transferred, requests):
        """Compare all providers"""
        results = {}
        
        for provider in self.PRICES.keys():
            results[provider] = self.calculate_annual_cost(
                provider, gb_stored, gb_transferred, requests
            )
        
        return results


# Example: 1TB stored, 100GB egress, 1M requests monthly
calculator = StorageCostCalculator()
results = calculator.compare_providers(1000, 100, 1000000)

print("Annual Costs Comparison (1TB storage, 100GB egress, 1M requests):")
for provider, cost in results.items():
    print(f"  {provider}: ${cost:.2f}")

// Deploy static website to IPFS + Filecoin
const { create: createIPFSClient } = require('ipfs-http-client');
const { Filecoin } = require('filecoin-lotus-client');

async function deployWebsite(directoryPath) {
    const ipfs = createIPFSClient({ url: '/ip4/127.0.0.1/tcp/5001' });
    
    // 1. Upload all files to IPFS
    const files = await getAllFiles(directoryPath);
    let rootCid;
    
    for (const file of files) {
        const content = await fs.promises.readFile(file.path);
        const result = await ipfs.add({
            path: file.relativePath,
            content: content
        });
        if (file.isRoot) rootCid = result.path;
    }
    
    // 2. Pin the site
    await ipfs.pin.add(rootCid);
    
    // 3. Make Filecoin deal for permanence
    const filecoin = new Filecoin('https://api.node.glif.io/rpc/v0');
    await filecoin.client.deal(rootCid, {
        miner: 'f01234',
        duration: 518400
    });
    
    // 4. Create DNS record
    // Use ENS or traditional DNS with IPNS
    await createDNSRecord('yoursite.com', rootCid);
    
    return {
        ipfsCid: rootCid,
        url: `https://ipfs.io/ipfs/${rootCid}`,
        ens: 'yoursite.eth'
    };
}