Types

import type { PieceCID } from '@filoz/synapse-sdk'
import * as Piece from '@filoz/synapse-core/piece'

const pieceCid: PieceCID = Piece.calculate(data)
console.log(pieceCid.toString()) // baga6ea4seaq...

import type { Address } from 'viem'

const address: Address = '0x...'

import type { Hash } from 'viem'

const txHash: Hash = '0x...'

interface UploadResult {
  pieceCid: PieceCID
  size: number
  copies: CopyResult[]
  failures: FailedCopy[]
}

interface CopyResult {
  providerId: bigint
  dataSetId: bigint
  pieceId: bigint
  role: 'primary' | 'secondary'
  retrievalUrl: string
  isNewDataSet: boolean
}

interface FailedCopy {
  providerId: bigint
  role: 'primary' | 'secondary'
  error: string
  explicit: boolean
}

interface StoreResult {
  pieceCid: PieceCID
  size: number
}

interface CommitResult {
  txHash: Hash
  pieceIds: bigint[]
  dataSetId: bigint
  isNewDataSet: boolean
}

interface PullResult {
  status: 'complete' | 'failed'
  pieces: Array<{
    pieceCid: PieceCID
    status: 'complete' | 'failed'
  }>
}

interface DataSetInfo {
  pdpRailId: bigint
  cacheMissRailId: bigint
  cdnRailId: bigint
  payer: Address
  payee: Address
  serviceProvider: Address
  commissionBps: bigint
  clientDataSetId: bigint
  pdpEndEpoch: bigint
  providerId: bigint
  dataSetId: bigint
}

interface EnhancedDataSetInfo extends DataSetInfo {
  pdpVerifierDataSetId: bigint
  activePieceCount: bigint
  isLive: boolean
  isManaged: boolean
  withCDN: boolean
  metadata: Record<string, string>
}

interface PDPProvider {
  id: bigint
  serviceProvider: Address
  name: string
  description: string
  pdp: {
    serviceURL: string
    minPieceSizeInBytes: bigint
    maxPieceSizeInBytes: bigint
  }
  capabilities?: Record<string, string>
}

interface UploadCallbacks {
  onProgress?: (bytesUploaded: number) => void
  onStored?: (providerId: bigint, pieceCid: PieceCID) => void
  onPiecesAdded?: (txHash: Hash, providerId: bigint, pieces: { pieceCid: PieceCID }[]) => void
  onPiecesConfirmed?: (dataSetId: bigint, providerId: bigint, pieces: PieceRecord[]) => void
  onCopyComplete?: (providerId: bigint, pieceCid: PieceCID) => void
  onCopyFailed?: (providerId: bigint, pieceCid: PieceCID, error: Error) => void
  onPullProgress?: (providerId: bigint, pieceCid: PieceCID, status: PullStatus) => void
}

interface StorageContextCallbacks {
  onProviderSelected?: (provider: PDPProvider) => void
  onDataSetResolved?: (info: { dataSetId: bigint; provider: PDPProvider }) => void
}

interface SynapseOptions {
  transport?: Transport
  chain?: Chain
  account: Account | Address
  sessionKey?: SessionKey<'Secp256k1'>
  withCDN?: boolean
}

interface CreateContextsOptions {
  count?: number
  dataSetIds?: bigint[]
  providerIds?: bigint[]
  excludeProviderIds?: bigint[]
  withCDN?: boolean
  metadata?: Record<string, string>
  callbacks?: StorageContextCallbacks
}

interface StorageManagerUploadOptions extends CreateContextsOptions {
  contexts?: StorageContext[]
  callbacks?: Partial<CombinedCallbacks>
  pieceCid?: PieceCID
  signal?: AbortSignal
  pieceMetadata?: Record<string, string>
}

type MetadataObject = Record<string, string>

const metadata: MetadataObject = {
  category: 'videos',
  project: 'alpha'
}

interface MetadataEntry {
  key: string
  value: string
}

const entries: MetadataEntry[] = [
  { key: 'category', value: 'videos' },
  { key: 'project', value: 'alpha' }
]

interface RailInfo {
  railId: bigint
  payer: Address
  payee: Address
  rate: bigint
  lockup: bigint
  // ... other fields
}

interface SettlementResult {
  totalSettledAmount: bigint
  totalNetPayeeAmount: bigint
  totalOperatorCommission: bigint
  totalNetworkFee: bigint
  finalSettledEpoch: bigint
  note: string
}

interface StorageInfo {
  pricing: {
    noCDN: {
      perTiBPerMonth: bigint
      perTiBPerDay: bigint
      perTiBPerEpoch: bigint
    }
    withCDN: {
      perTiBPerMonth: bigint
      perTiBPerDay: bigint
      perTiBPerEpoch: bigint
    }
    tokenAddress: Address
    tokenSymbol: string
  }
  providers: PDPProvider[]
  serviceParameters: {
    epochsPerMonth: bigint
    epochsPerDay: bigint
    epochDuration: number
    minUploadSize: number
    maxUploadSize: number
  }
  allowances: {
    isApproved: boolean
    service: Address
    rateAllowance: bigint
    lockupAllowance: bigint
    rateUsed: bigint
    lockupUsed: bigint
  } | null
}

interface PreflightInfo {
  estimatedCost: {
    perEpoch: bigint
    perDay: bigint
    perMonth: bigint
  }
  allowanceCheck: {
    sufficient: boolean
    message?: string
  }
  selectedProvider: PDPProvider | null
  selectedDataSetId: number | null
}

type PullStatus = 'pending' | 'pulling' | 'complete' | 'failed'

type TokenIdentifier = 'USDFC' | 'FIL'

type TokenAmount = bigint