List

async list(options?: ListOptions): Promise<FileInfo[]>

interface ListOptions {
  filterBy?: 'public' | 'private';                // Filter by access type
  sortBy?: 'uploadedAt' | 'fileSize' | 'fileName'; // Sort field
  sortOrder?: 'asc' | 'desc';                      // Sort direction
  limit?: number;                                  // Maximum number of files to return
  offset?: number;                                 // Number of files to skip
  includeMetadata?: boolean;                       // Include file metadata (default: true)
  onProgress?: (progress: ListProgress) => void;   // Progress callback
}

interface ListProgress {
  message: string;
  current?: number;
  total?: number;
}

interface FileInfo {
  pieceCid: string;         // Filecoin piece CID of the file
  fileName?: string;        // File name
  fileSize?: number;        // File size in bytes
  isPublic: boolean;        // Whether file is publicly accessible
  owner?: string;           // Wallet address that uploaded the file
  uploader?: string;        // Alternative field for uploader address
  dataIdentifier?: string;  // Data identifier for backwards compatibility
  uploadedAt?: string;      // ISO timestamp of upload
  contractAddress?: string; // Smart contract address
  shares?: Array<{          // Array of addresses file is shared with
    recipientAddress: string;
    createdAt?: string;
  }>;
  metadata?: object;        // File metadata object
}

import { Synapse } from '@filoz/synapse-sdk';
import { SynapseStorageSDK } from '@keypo/synapse-storage-sdk';
import { ethers } from 'ethers';
 
// Initialize wallet and provider
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY);
const provider = new ethers.JsonRpcProvider('https://api.calibration.node.glif.io/rpc/v1');
const signer = wallet.connect(provider);
 
// Initialize Synapse
const synapse = await Synapse.create({
  signer,
  withCDN: true,
});
 
// Initialize SDK
const sdk = new SynapseStorageSDK(synapse, {
  network: 'calibration',
  rpcUrl: 'https://api.calibration.node.glif.io/rpc/v1',
  encryption: {
    registryAddress: '0x8370eE1a51B5F31cc10E2f4d786Ff20198B10BBE',
    validationAddress: '0x35ADB6b999AbcD5C9CdF2262c7190C7b96ABcE4C',
    bundlerRpcUrl: 'https://rpc.zerodev.app/api/v3/YOUR_PROJECT_ID/chain/84532'
  },
  storage: {
    withCDN: true
  }
}, process.env.PRIVATE_KEY);
 
// List all files
const files = await sdk.list();
 
console.log(`Found ${files.length} files:`);
files.forEach((file, index) => {
  console.log(`${index + 1}. ${file.fileName || 'Unnamed file'}`);
  console.log(`   Piece CID: ${file.pieceCid}`);
  console.log(`   Access: ${file.isPublic ? 'Public' : 'Private'}`);
  console.log(`   Owner: ${file.owner || file.uploader}`);
});

// List only private files, sorted by upload date (newest first)
const privateFiles = await sdk.list({
  filterBy: 'private',
  sortBy: 'uploadedAt',
  sortOrder: 'desc',
  limit: 10,
  onProgress: (progress) => {
    console.log(progress.message);
  }
});
 
console.log(`Found ${privateFiles.length} private files:`);
privateFiles.forEach(file => {
  console.log(`- ${file.fileName || 'Unnamed'} (${file.pieceCid})`);
});
 
// List public files sorted by file size
const publicFiles = await sdk.list({
  filterBy: 'public',
  sortBy: 'fileSize',
  sortOrder: 'desc'
});
 
console.log('Public files by size:');
publicFiles.forEach(file => {
  const sizeStr = file.fileSize ? `${(file.fileSize / 1024).toFixed(2)} KB` : 'Unknown size';
  console.log(`- ${file.fileName || 'Unnamed'}: ${sizeStr}`);
});

const files = await sdk.list({
  includeMetadata: true,
  onProgress: (progress) => {
    console.log(`Fetching files: ${progress.message}`);
  }
});
 
const walletAddress = await signer.getAddress();
 
files.forEach((file, index) => {
  console.log(`\nFile #${index + 1}:`);
  console.log(`  Name: ${file.fileName || 'Unnamed file'}`);
  console.log(`  Piece CID: ${file.pieceCid}`);
  console.log(`  Access: ${file.isPublic ? 'Public' : 'Private'}`);
  
  // Check if you own the file
  const owner = file.owner || file.uploader;
  const isMyFile = owner && owner.toLowerCase() === walletAddress.toLowerCase();
  console.log(`  Owner: ${owner}${isMyFile ? ' (You)' : ''}`);
  
  if (file.uploadedAt) {
    console.log(`  Uploaded: ${new Date(file.uploadedAt).toLocaleString()}`);
  }
  
  if (file.shares && file.shares.length > 0) {
    console.log(`  Shared with: ${file.shares.length} user(s)`);
  }
  
  if (file.metadata && Object.keys(file.metadata).length > 0) {
    console.log(`  Metadata:`, file.metadata);
  }
});