StorageContext

const context = await synapse.storage.createContext()
console.log(context.provider.id)
console.log(context.provider.pdp.serviceURL)

if (context.dataSetId) {
  console.log('Using existing dataset:', context.dataSetId)
} else {
  console.log('Will create new dataset on commit')
}

console.log(context.dataSetMetadata)
// { category: 'videos', cdn: '' }

if (context.withCDN) {
  console.log('CDN enabled')
}

store() → pull() → commit()
  │        │         │
  │        │         └── On-chain registration
  │        └────────── SP-to-SP transfer
  └─────────────────── Upload to provider

const context = await synapse.storage.createContext()

// Store data on provider (not yet on-chain)
const { pieceCid, size } = await context.store(data, {
  onProgress: (bytes) => console.log(`Uploaded ${bytes} bytes`)
})

console.log('Stored:', pieceCid.toString())

const extraData = await context.presignForCommit([
  { pieceCid, pieceMetadata: { tag: 'important' } }
])

// Use extraData in pull and commit to avoid re-signing
await context.pull({ pieces: [pieceCid], from: sourceUrl, extraData })
await context.commit({ pieces: [{ pieceCid }], extraData })

const primary = contexts[0]
const secondary = contexts[1]

// Store on primary
const { pieceCid } = await primary.store(data)

// Pull to secondary from primary
const pullResult = await secondary.pull({
  pieces: [pieceCid],
  from: (cid) => primary.getPieceUrl(cid),
  onProgress: (cid, status) => console.log(`Pull: ${status}`)
})

if (pullResult.status === 'complete') {
  console.log('Pull successful')
}

// Store data first
const { pieceCid } = await context.store(data)

// Commit on-chain
const result = await context.commit({
  pieces: [{ pieceCid, pieceMetadata: { tag: 'doc' } }],
  onSubmitted: (txHash) => console.log('Tx submitted:', txHash)
})

console.log('Dataset ID:', result.dataSetId)
console.log('Piece ID:', result.pieceIds[0])
console.log('New dataset:', result.isNewDataSet)

const context = await synapse.storage.createContext()

const result = await context.upload(data, {
  pieceMetadata: { category: 'images' },
  onProgress: (bytes) => console.log(`Uploaded ${bytes} bytes`),
  onStored: (providerId, pieceCid) => console.log('Stored'),
  onPiecesConfirmed: (dataSetId, providerId, pieces) => 
    console.log('Confirmed on-chain')
})

console.log('Copy:', result.copies[0])

const data = await context.download({
  pieceCid: 'baga6ea4seaq...'
})

const url = context.getPieceUrl(pieceCid)
console.log('Retrieve from:', url)

const exists = await context.hasPiece({ pieceCid })
if (exists) {
  console.log('Piece is available')
}

const status = await context.pieceStatus({ pieceCid })

console.log('Exists:', status.exists)
if (status.dataSetLastProven) {
  console.log('Last proven:', status.dataSetLastProven)
}
if (status.dataSetNextProofDue) {
  console.log('Next proof due:', status.dataSetNextProofDue)
}
if (status.isProofOverdue) {
  console.warn('Proof is overdue!')
}

for await (const piece of context.getPieces()) {
  console.log(`Piece ${piece.pieceId}: ${piece.pieceCid}`)
}

// With custom batch size
for await (const piece of context.getPieces({ batchSize: 50n })) {
  // Process piece
}

// By piece CID
const txHash = await context.deletePiece({ piece: pieceCid })

// By piece ID
const txHash = await context.deletePiece({ piece: 42n })

const scheduled = await context.getScheduledRemovals()
console.log('Pieces to be removed:', scheduled)

const info = await context.getProviderInfo()
console.log('Provider:', info.serviceProvider)
console.log('PDP URL:', info.pdp.serviceURL)

const preflight = await context.preflightUpload({
  size: 1024 * 1024 * 50 // 50 MiB
})

console.log('Estimated cost/month:', preflight.estimatedCost.perMonth)

const txHash = await context.terminate()
console.log('Dataset terminated:', txHash)

import { Synapse } from '@filoz/synapse-sdk'

const synapse = Synapse.create({ account, chain })

// Create contexts for 3 providers
const [primary, secondary1, secondary2] = 
  await synapse.storage.createContexts({ count: 3 })

// Store on primary
const { pieceCid } = await primary.store(data)

// Pre-sign for both secondaries
const extraData1 = await secondary1.presignForCommit([{ pieceCid }])
const extraData2 = await secondary2.presignForCommit([{ pieceCid }])

// Pull to secondaries in parallel
await Promise.all([
  secondary1.pull({
    pieces: [pieceCid],
    from: (cid) => primary.getPieceUrl(cid),
    extraData: extraData1
  }),
  secondary2.pull({
    pieces: [pieceCid],
    from: (cid) => primary.getPieceUrl(cid),
    extraData: extraData2
  })
])

// Commit all in parallel
const commits = await Promise.all([
  primary.commit({ pieces: [{ pieceCid }] }),
  secondary1.commit({ pieces: [{ pieceCid }], extraData: extraData1 }),
  secondary2.commit({ pieces: [{ pieceCid }], extraData: extraData2 })
])

console.log('All copies committed')