feat: check payments status on import command

rvagg · rvagg · commit 91b56284a25e · 2025-09-20T09:06:38.000+10:00
diff --git a/src/import/car-import.ts b/src/import/car-import.ts
@@ -12,6 +12,8 @@ import { CarReader } from '@ipld/car'
 import { CID } from 'multiformats/cid'
 import pc from 'picocolors'
 import pino from 'pino'
+import { checkInsufficientFunds, formatUSDFC } from '../payments/setup.js'
+import { checkFILBalance, checkUSDFCBalance, validatePaymentCapacity } from '../synapse/payments.js'
 import { cleanupSynapseService, initializeSynapse } from '../synapse/service.js'
 import { uploadToSynapse } from '../synapse/upload.js'
 import { createSpinner, formatFileSize, intro } from '../utils/cli-helpers.js'
@@ -166,8 +168,100 @@ export async function runCarImport(options: ImportOptions): Promise<ImportResult
 
     spinner.stop(`${pc.green('✓')} Connected to ${pc.bold(network)}`)
 
-    // Step 5: Read CAR file and upload to Synapse
-    spinner.start('Uploading to Filecoin...')
+    // Step 5: Validate payment setup
+    spinner.start('Validating payment setup...')
+
+    // First check basic requirements (FIL and USDFC balance)
+    const { isCalibnet, hasSufficientGas } = await checkFILBalance(synapseService.synapse)
+    const usdfcBalance = await checkUSDFCBalance(synapseService.synapse)
+
+    // Check basic requirements using existing function
+    const hasBasicRequirements = checkInsufficientFunds(hasSufficientGas, usdfcBalance, isCalibnet, false)
+
+    if (!hasBasicRequirements) {
+      spinner.stop(`${pc.red('✗')} Payment setup incomplete`)
+      log.line('')
+      log.line(`${pc.yellow('⚠')} Your payment setup is not complete. Please run:`)
+      log.indent(pc.cyan('filecoin-pin payments setup'))
+      log.line('')
+      log.line('For more information, run:')
+      log.indent(pc.cyan('filecoin-pin payments status'))
+      log.flush()
+      await cleanupSynapseService()
+      process.exit(1)
+    }
+
+    // Now check capacity for this specific file
+    const capacityCheck = await validatePaymentCapacity(synapseService.synapse, fileStat.size)
+
+    if (!capacityCheck.canUpload) {
+      spinner.stop(`${pc.red('✗')} Insufficient payment capacity for this file`)
+      log.line('')
+      log.line(pc.bold('File Requirements:'))
+      log.indent(`File size: ${formatFileSize(fileStat.size)} (${capacityCheck.storageTiB.toFixed(4)} TiB)`)
+      log.indent(`Storage cost: ${formatUSDFC(capacityCheck.required.rateAllowance)} USDFC/epoch`)
+      log.indent(`10-day lockup: ${formatUSDFC(capacityCheck.required.lockupAllowance)} USDFC`)
+      log.line('')
+
+      log.line(pc.bold(`${pc.red('Issues found:')}`))
+      if (capacityCheck.issues.insufficientDeposit) {
+        log.indent(
+          `${pc.red('✗')} Insufficient deposit (need ${formatUSDFC(capacityCheck.issues.insufficientDeposit)} more)`
+        )
+      }
+      if (capacityCheck.issues.insufficientRateAllowance) {
+        log.indent(
+          `${pc.red('✗')} Rate allowance too low (need ${formatUSDFC(capacityCheck.issues.insufficientRateAllowance)} more per epoch)`
+        )
+      }
+      if (capacityCheck.issues.insufficientLockupAllowance) {
+        log.indent(
+          `${pc.red('✗')} Lockup allowance too low (need ${formatUSDFC(capacityCheck.issues.insufficientLockupAllowance)} more)`
+        )
+      }
+      log.line('')
+
+      log.line(pc.bold('Suggested actions:'))
+      capacityCheck.suggestions.forEach((suggestion) => {
+        log.indent(`• ${suggestion}`)
+      })
+      log.line('')
+
+      // Calculate suggested parameters for payment setup
+      const suggestedDeposit = capacityCheck.issues.insufficientDeposit
+        ? formatUSDFC(capacityCheck.issues.insufficientDeposit)
+        : '0'
+      const suggestedStorage = `${Math.ceil(capacityCheck.storageTiB * 10) / 10}TiB/month`
+
+      log.line(`${pc.yellow('⚠')} To fix these issues, run:`)
+      if (capacityCheck.issues.insufficientDeposit) {
+        log.indent(
+          pc.cyan(`filecoin-pin payments setup --deposit ${suggestedDeposit} --storage ${suggestedStorage} --auto`)
+        )
+      } else {
+        log.indent(pc.cyan(`filecoin-pin payments setup --storage ${suggestedStorage} --auto`))
+      }
+      log.flush()
+      await cleanupSynapseService()
+      process.exit(1)
+    }
+
+    // Show warning if suggestions exist (even if upload is possible)
+    if (capacityCheck.suggestions.length > 0 && capacityCheck.canUpload) {
+      spinner.stop(`${pc.yellow('⚠')} Payment capacity check passed with warnings`)
+      log.line('')
+      log.line(pc.bold('Suggestions:'))
+      capacityCheck.suggestions.forEach((suggestion) => {
+        log.indent(`• ${suggestion}`)
+      })
+      log.flush()
+      spinner.start('Uploading to Filecoin...')
+    } else {
+      spinner.stop(`${pc.green('✓')} Payment capacity verified`)
+      spinner.start('Uploading to Filecoin...')
+    }
+
+    // Step 6: Read CAR file and upload to Synapse
 
     // Read the entire CAR file (streaming not yet supported in Synapse)
     const carData = await readFile(options.filePath)
diff --git a/src/synapse/payments.ts b/src/synapse/payments.ts
@@ -345,3 +345,110 @@ export function calculateStorageFromUSDFC(usdfcAmount: bigint, pricePerTiBPerEpo
   const capacityTiB = Number((ratePerEpoch * 100n) / pricePerTiBPerEpoch) / 100
   return capacityTiB
 }
+
+/**
+ * Calculate required allowances from CAR file size
+ *
+ * Simple wrapper that converts file size to storage allowances.
+ *
+ * @param carSizeBytes - Size of the CAR file in bytes
+ * @param pricePerTiBPerEpoch - Current pricing from storage service
+ * @returns Required allowances for the file
+ */
+export function calculateRequiredAllowances(carSizeBytes: number, pricePerTiBPerEpoch: bigint): StorageAllowances {
+  // Convert bytes to TiB (1 TiB = 1024^4 bytes)
+  const bytesPerTiB = 1024 * 1024 * 1024 * 1024
+  const storageTiB = carSizeBytes / bytesPerTiB
+  return calculateStorageAllowances(storageTiB, pricePerTiBPerEpoch)
+}
+
+/**
+ * Payment capacity validation for a specific file
+ */
+export interface PaymentCapacityCheck {
+  canUpload: boolean
+  storageTiB: number
+  required: StorageAllowances
+  issues: {
+    insufficientDeposit?: bigint
+    insufficientRateAllowance?: bigint
+    insufficientLockupAllowance?: bigint
+  }
+  suggestions: string[]
+}
+
+/**
+ * Validate payment capacity for a specific CAR file
+ *
+ * Checks if the current payment setup can handle uploading a specific file.
+ * This is a focused check on capacity, not basic setup validation.
+ *
+ * Example usage:
+ * ```typescript
+ * const fileSize = 10 * 1024 * 1024 * 1024 // 10 GiB
+ * const capacity = await validatePaymentCapacity(synapse, fileSize)
+ *
+ * if (!capacity.canUpload) {
+ *   console.error('Cannot upload file with current payment setup')
+ *   capacity.suggestions.forEach(s => console.log(`  - ${s}`))
+ * }
+ * ```
+ *
+ * @param synapse - Initialized Synapse instance
+ * @param carSizeBytes - Size of the CAR file in bytes
+ * @returns Capacity check result with specific issues
+ */
+export async function validatePaymentCapacity(synapse: Synapse, carSizeBytes: number): Promise<PaymentCapacityCheck> {
+  // Get current status and pricing
+  const [status, storageInfo] = await Promise.all([getPaymentStatus(synapse), synapse.storage.getStorageInfo()])
+
+  const pricePerTiBPerEpoch = storageInfo.pricing.noCDN.perTiBPerEpoch
+  const bytesPerTiB = 1024 * 1024 * 1024 * 1024
+  const storageTiB = carSizeBytes / bytesPerTiB
+
+  // Calculate requirements
+  const required = calculateRequiredAllowances(carSizeBytes, pricePerTiBPerEpoch)
+  const monthlyPayment = required.rateAllowance * TIME_CONSTANTS.EPOCHS_PER_MONTH
+  const totalDepositNeeded = required.lockupAllowance + monthlyPayment
+
+  const result: PaymentCapacityCheck = {
+    canUpload: true,
+    storageTiB,
+    required,
+    issues: {},
+    suggestions: [],
+  }
+
+  // Check deposit
+  if (status.depositedAmount < totalDepositNeeded) {
+    result.canUpload = false
+    result.issues.insufficientDeposit = totalDepositNeeded - status.depositedAmount
+    const depositNeeded = ethers.formatUnits(totalDepositNeeded - status.depositedAmount, 18)
+    result.suggestions.push(`Deposit at least ${depositNeeded} USDFC`)
+  }
+
+  // Check rate allowance
+  if (status.currentAllowances.rateAllowance < required.rateAllowance) {
+    result.canUpload = false
+    result.issues.insufficientRateAllowance = required.rateAllowance - status.currentAllowances.rateAllowance
+    const rateNeeded = ethers.formatUnits(required.rateAllowance, 18)
+    result.suggestions.push(`Set rate allowance to at least ${rateNeeded} USDFC/epoch`)
+  }
+
+  // Check lockup allowance
+  if (status.currentAllowances.lockupAllowance < required.lockupAllowance) {
+    result.canUpload = false
+    result.issues.insufficientLockupAllowance = required.lockupAllowance - status.currentAllowances.lockupAllowance
+    const lockupNeeded = ethers.formatUnits(required.lockupAllowance, 18)
+    result.suggestions.push(`Set lockup allowance to at least ${lockupNeeded} USDFC`)
+  }
+
+  // Add warning if approaching deposit limit
+  const totalLockupAfter = status.currentAllowances.lockupUsed + required.lockupAllowance
+  if (totalLockupAfter > (status.depositedAmount * 9n) / 10n && result.canUpload) {
+    const additionalDeposit = ethers.formatUnits((totalLockupAfter * 11n) / 10n - status.depositedAmount, 18)
+    result.suggestions.push(`Consider depositing ${additionalDeposit} more USDFC for safety margin`)
+  }
+
+  return result
+}
diff --git a/src/test/unit/car-import.test.ts b/src/test/unit/car-import.test.ts
@@ -23,6 +23,29 @@ import type { ImportOptions } from '../../import/types.js'
 
 // Mock modules
 vi.mock('@filoz/synapse-sdk', async () => await import('../mocks/synapse-sdk.js'))
+vi.mock('../../synapse/payments.js', () => ({
+  checkFILBalance: vi.fn().mockResolvedValue({
+    balance: 1000000000000000000n, // 1 FIL
+    isCalibnet: true,
+    hasSufficientGas: true,
+  }),
+  checkUSDFCBalance: vi.fn().mockResolvedValue(1000000000000000000000n), // 1000 USDFC
+  validatePaymentCapacity: vi.fn().mockResolvedValue({
+    canUpload: true,
+    storageTiB: 0.001,
+    required: {
+      rateAllowance: 100000000000000n,
+      lockupAllowance: 1000000000000000000n,
+      storageCapacityTiB: 0.001,
+    },
+    issues: {},
+    suggestions: [],
+  }),
+}))
+vi.mock('../../payments/setup.js', () => ({
+  checkInsufficientFunds: vi.fn().mockReturnValue(true),
+  formatUSDFC: vi.fn((amount) => `${amount} USDFC`),
+}))
 vi.mock('../../synapse/service.js', async () => {
   const { MockSynapse } = await import('../mocks/synapse-mocks.js')
 
