@filoz/repair-cli 0.0.1

package/src/commands/providers.ts

@@ -0,0 +1,99 @@
+import { and, asc, count, eq, inArray, isNull, lte, or, type SQLWrapper, sum } from 'drizzle-orm'
+import { Cli, z } from 'incur'
+import { getBlockNumber } from 'viem/actions'
+import { contextMiddleware, contextSchema } from '../middleware.ts'
+import { globalOptions } from '../utils.ts'
+
+/** Format byte count as decimal gigabytes with two fractional digits. */
+function formatBytesAsGb(bytes: bigint): string {
+  const scaled = (bytes * 100n) / 1_000_000_000n
+  const whole = scaled / 100n
+  const fraction = scaled % 100n
+  return `${whole}.${fraction.toString().padStart(2, '0')} GB`
+}
+
+export const providers = Cli.create('providers', {
+  description: 'Provider commands',
+  options: globalOptions,
+  vars: contextSchema,
+})
+
+providers.command('list', {
+  description: 'List all providers from the indexer',
+  options: globalOptions.extend({
+    all: z.boolean().optional().default(false).describe('Include all providers'),
+  }),
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const schema = c.var.indexerDb._.fullSchema
+      const filters: (SQLWrapper | undefined)[] = [
+        eq(schema.providers.providerActive, true),
+        eq(schema.providers.pdpProductActive, true),
+        // or(eq(schema.providers.approved, true), eq(schema.providers.endorsed, true)),
+      ]
+      if (!c.options.all) {
+        filters.push(or(eq(schema.providers.approved, true), eq(schema.providers.endorsed, true)))
+      }
+      const blockNumber = await getBlockNumber(c.var.client)
+      const rows = await c.var.indexerDb.query.providers.findMany({
+        orderBy: [asc(schema.providers.providerId)],
+        where: and(...filters),
+      })
+
+      const providerIds = rows.map((provider) => provider.providerId)
+      const statsByProviderId = new Map<bigint, { pieceCount: number; totalSize: bigint }>()
+
+      if (providerIds.length > 0) {
+        const stats = await c.var.indexerDb
+          .select({
+            providerId: schema.dataSets.providerId,
+            pieceCount: count(schema.pieces.pieceId),
+            totalSize: sum(schema.pieces.rawSize),
+          })
+          .from(schema.pieces)
+          .innerJoin(schema.dataSets, eq(schema.pieces.dataSetId, schema.dataSets.dataSetId))
+          .where(
+            and(
+              inArray(schema.dataSets.providerId, providerIds),
+              eq(schema.dataSets.deleted, false),
+              or(isNull(schema.dataSets.pdpEndEpoch), lte(schema.dataSets.pdpEndEpoch, blockNumber)),
+              eq(schema.pieces.removed, false)
+            )
+          )
+          .groupBy(schema.dataSets.providerId)
+
+        for (const stat of stats) {
+          statsByProviderId.set(stat.providerId, {
+            pieceCount: stat.pieceCount,
+            totalSize: stat.totalSize == null ? 0n : BigInt(stat.totalSize),
+          })
+        }
+      }
+
+      const providersFlattened = rows.map((provider) => {
+        const stats = statsByProviderId.get(provider.providerId)
+        return {
+          id: provider.providerId,
+          name: provider.name,
+          serviceUrl: provider.serviceUrl,
+          approved: provider.approved,
+          endorsed: provider.endorsed,
+          pieceCount: stats?.pieceCount ?? 0,
+          totalSize: formatBytesAsGb(stats?.totalSize ?? 0n),
+        }
+      })
+
+      return c.ok({
+        providers: providersFlattened,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'PROVIDERS_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to list providers',
+        retryable: true,
+      })
+    }
+  },
+})

package/src/commands/repair.ts

@@ -0,0 +1,177 @@
+import { and, desc, eq, inArray } from 'drizzle-orm'
+import { Cli, z } from 'incur'
+import { repairCreate } from '../db/repair-create.ts'
+import { repairDelete } from '../db/repair-delete.ts'
+import { contextMiddleware, contextSchema } from '../middleware.ts'
+import { ensureRepairDataset } from '../pipeline/create-datasets.ts'
+import { runPullPiecesPhase } from '../pipeline/pull.ts'
+import { globalOptions } from '../utils.ts'
+export const repair = Cli.create('repair', {
+  description: 'Repair commands',
+  vars: contextSchema,
+})
+
+repair.command('create', {
+  description: 'Create a new repair',
+  options: globalOptions.extend({
+    providerId: z.coerce.bigint().describe('Provider ID to repair'),
+    targetProviderId: z.coerce.bigint().describe('Target provider ID for repair'),
+  }),
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const { providerId, targetProviderId } = c.options
+
+      const repairId = await repairCreate({
+        ...c.var,
+        repairProviderId: providerId,
+        targetProviderId,
+      })
+
+      return c.ok({
+        repairId,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPAIR_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to repair the dataset',
+        retryable: true,
+      })
+    }
+  },
+})
+
+repair.command('list', {
+  description: 'List all repairs',
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const localSchema = c.var.localDb._.fullSchema
+      const repairs = await c.var.localDb.query.repairs.findMany({
+        orderBy: [desc(localSchema.repairs.createdAt)],
+        with: {
+          operations: true,
+        },
+      })
+
+      const repairFlattened = repairs.map((repair) => {
+        const { operations, ...repairWithoutOperations } = repair
+        return {
+          id: repairWithoutOperations.id,
+          status: repairWithoutOperations.status,
+          repairProviderId: repairWithoutOperations.repairProviderId,
+          targetProviderId: repairWithoutOperations.targetProviderId,
+          targetProviderUrl: repairWithoutOperations.targetProviderUrl,
+          targetDataSetId: repairWithoutOperations.targetDataSetId,
+          blockNumber: repairWithoutOperations.blockNumber,
+          operations: operations.length,
+          pending: operations.filter((operation) => operation.status === 'pending').length,
+          failed: operations.filter((operation) => operation.status === 'failed').length,
+          completed: operations.filter((operation) => operation.status === 'completed').length,
+          skipped: operations.filter((operation) => operation.status === 'skipped').length,
+        }
+      })
+
+      return c.ok({
+        repairs: repairFlattened,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPAIR_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to repair the dataset',
+        retryable: true,
+      })
+    }
+  },
+})
+
+repair.command('delete', {
+  description: 'Delete a repair',
+  args: z.object({
+    repairId: z.coerce.number().describe('Repair ID to delete'),
+  }),
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const { deleted, operationsDeleted } = await repairDelete({
+        localDb: c.var.localDb,
+        repairId: c.args.repairId,
+      })
+
+      if (!deleted) {
+        return c.error({
+          code: 'REPAIR_NOT_FOUND',
+          message: 'Repair not found',
+          retryable: false,
+        })
+      }
+
+      return c.ok({
+        repairId: c.args.repairId,
+        operationsDeleted,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPAIR_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to delete the repair',
+        retryable: true,
+      })
+    }
+  },
+})
+
+repair.command('run', {
+  description: 'Run a repair',
+  args: z.object({
+    repairId: z.coerce.number().describe('Repair ID to run'),
+  }),
+  options: globalOptions.extend({
+    concurrency: z.coerce.number().default(4).describe('Concurrency level'),
+    batchSize: z.coerce.number().default(40).describe('Max add_piece operations per pull batch'),
+    reset: z.boolean().default(false).describe('Reset the repair'),
+  }),
+  middleware: [contextMiddleware],
+  run: async (c) => {
+    try {
+      const schema = c.var.localDb._.fullSchema
+      const repair = await c.var.localDb.query.repairs.findFirst({
+        where: and(eq(schema.repairs.id, c.args.repairId), inArray(schema.repairs.status, ['pending'])),
+      })
+      if (!repair) {
+        return c.error({
+          code: 'REPAIR_NOT_FOUND',
+          message: 'Repair not found, it may have already been run or completed',
+          retryable: false,
+        })
+      }
+
+      await ensureRepairDataset({
+        ...c.var,
+        repair,
+      })
+
+      await runPullPiecesPhase({
+        ...c.var,
+        repair,
+        concurrency: c.options.concurrency,
+        batchSize: c.options.batchSize,
+        reset: c.options.reset,
+      })
+      return c.ok({
+        repairId: repair.id,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'REPAIR_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to repair the dataset',
+        retryable: true,
+      })
+    }
+  },
+})

package/src/commands/setup.ts

@@ -0,0 +1,142 @@
+import * as p from '@clack/prompts'
+import { Cli, z } from 'incur'
+import path from 'path'
+import type { Hash } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { config, createLocalDatabase, globalOptions, migrateLocalDatabase } from '../utils.ts'
+
+function validatePostgresUrl(value: string) {
+  let url: URL
+  try {
+    url = new URL(value)
+  } catch {
+    return false
+  }
+
+  if (url.protocol !== 'postgresql:' && url.protocol !== 'postgres:') {
+    return false
+  }
+
+  return Boolean(url.hostname && url.username && url.password && url.pathname.length > 1)
+}
+
+export const setup = Cli.create('setup', {
+  description: 'Setup the CLI',
+  options: globalOptions.extend({
+    privateKey: z.string().optional().describe('Private key to use'),
+  }),
+  run: async (c) => {
+    try {
+      // Private key
+      const pk = await p.text({
+        message: 'Enter your private key',
+        validate(value) {
+          if (!value || !/^0x[a-fA-F0-9]{64}$/.test(value)) {
+            return `Invalid private key!`
+          }
+        },
+        initialValue: config.get('privateKey'),
+        withGuide: false,
+      })
+      if (p.isCancel(pk)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+
+      // Indexer URL
+      const indexerMainnetUrl = await p.text({
+        message: 'Enter your Mainnet Indexer Postgres URL',
+        validate(value) {
+          if (!value || !validatePostgresUrl(value)) {
+            return `Invalid postgres URL!`
+          }
+        },
+        initialValue: config.get('indexerMainnetUrl'),
+        withGuide: false,
+      })
+      if (p.isCancel(indexerMainnetUrl)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+      const indexerCalibrationUrl = await p.text({
+        message: 'Enter your Calibration Indexer Postgres URL',
+        validate(value) {
+          if (!value || !validatePostgresUrl(value)) {
+            return `Invalid postgres URL!`
+          }
+        },
+        initialValue: config.get('indexerCalibrationUrl'),
+        withGuide: false,
+      })
+      if (p.isCancel(indexerCalibrationUrl)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+
+      // Chain
+      const chainId = await p.select({
+        message: 'Select your chain',
+        options: [
+          { value: 314, label: 'Mainnet' },
+          { value: 314159, label: 'Calibration' },
+        ],
+        withGuide: false,
+        initialValue: config.get('chainId'),
+      })
+      if (p.isCancel(chainId)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+
+      // DB path
+      const dbPath = await p.text({
+        message: 'Enter your DB path',
+        initialValue: config.get('dbPath') || path.join(path.dirname(config.path), 'sqlite.db'),
+        withGuide: false,
+      })
+      if (p.isCancel(dbPath)) {
+        return c.error({
+          code: 'SETUP_CANCELLED',
+          message: 'Setup cancelled',
+          retryable: false,
+        })
+      }
+
+      // Set config
+      config.set('privateKey', pk)
+      config.set('indexerMainnetUrl', indexerMainnetUrl)
+      config.set('indexerCalibrationUrl', indexerCalibrationUrl)
+      config.set('chainId', chainId)
+      config.set('dbPath', dbPath)
+
+      // setup database
+      const db = await createLocalDatabase(dbPath)
+      await migrateLocalDatabase(db)
+
+      const account = privateKeyToAccount(pk as Hash)
+
+      return c.ok({
+        address: account.address,
+      })
+    } catch (error) {
+      console.error(error)
+      return c.error({
+        code: 'SETUP_FAILED',
+        message: error instanceof Error ? error.message : 'Failed to setup the CLI',
+        retryable: true,
+      })
+    }
+  },
+})

package/src/commands/wallet.ts

@@ -0,0 +1,159 @@
+/** biome-ignore-all lint/suspicious/noConsole: cli */
+import { calibration } from '@filoz/synapse-core/chains'
+import * as ERC20 from '@filoz/synapse-core/erc20'
+import * as Pay from '@filoz/synapse-core/pay'
+import { claimTokens, formatBalance, formatFraction, parseUnits } from '@filoz/synapse-core/utils'
+import { Cli, z } from 'incur'
+import { getBalance, waitForTransactionReceipt } from 'viem/actions'
+import { contextMiddleware, contextSchema } from '../middleware.ts'
+import { globalOptions, hashLink } from '../utils.ts'
+
+export const wallet = Cli.create('wallet', {
+  description: 'Wallet commands',
+  vars: contextSchema,
+})
+
+wallet.command('fund', {
+  description: 'Fund a calibration wallet from a faucet',
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  async *run(c) {
+    const { client, chain } = c.var
+
+    if (chain.id !== calibration.id) {
+      return c.error({
+        code: 'INVALID_CHAIN',
+        message: `Wallet fund is only available on Filecoin Calibration (chain ID ${calibration.id})`,
+      })
+    }
+
+    yield 'Funding wallet...'
+    try {
+      const hashes = await claimTokens({ address: client.account.address })
+
+      yield `Waiting for tx ${hashLink(hashes[0].tx_hash, chain)} to be mined...`
+      await waitForTransactionReceipt(client, {
+        hash: hashes[0].tx_hash,
+      })
+      const balance = await getBalance(client, {
+        address: client.account.address,
+      })
+      yield {
+        address: client.account.address,
+        balance: formatBalance({ value: balance }),
+      }
+    } catch (error) {
+      if (c.options.debug) {
+        console.error(error)
+      }
+      return c.error({
+        code: 'FAILED_TO_FUND_WALLET',
+        message: 'Failed to fund wallet',
+      })
+    }
+  },
+})
+
+wallet.command('balance', {
+  description: 'Get wallet and pay account summary',
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  async run(c) {
+    const { client } = c.var
+    const balanceFIL = await getBalance(client, {
+      address: client.account.address,
+    })
+
+    const balanceUSDFC = await ERC20.balance(client, {
+      address: client.account.address,
+    })
+
+    const summary = await Pay.getAccountSummary(client, {
+      address: client.account.address,
+    })
+    return {
+      address: client.account.address,
+      fil: formatBalance({ value: balanceFIL }),
+      usdfc: formatBalance({ value: balanceUSDFC.value }),
+      pay: {
+        funds: formatBalance({ value: summary.funds }),
+        availableFunds: formatBalance({ value: summary.availableFunds }),
+        debt: formatBalance({ value: summary.debt }),
+        lockupRatePerEpoch: formatFraction({ value: summary.lockupRatePerEpoch }),
+        lockupRatePerMonth: formatBalance({ value: summary.lockupRatePerMonth }),
+        totalLockup: formatBalance({ value: summary.totalLockup }),
+        totalFixedLockup: formatBalance({ value: summary.totalFixedLockup }),
+        totalRateBasedLockup: formatBalance({ value: summary.totalRateBasedLockup }),
+        runwayInEpochs: summary.runwayInEpochs,
+        grossCoverageInEpochs: summary.grossCoverageInEpochs,
+        epoch: summary.epoch,
+      },
+    }
+  },
+})
+
+wallet.command('deposit', {
+  description: 'Deposit wallet funds to a pay account',
+  args: z.object({
+    amount: z.coerce.number().gt(0).describe('Amount of USDFC to deposit'),
+  }),
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  async *run(c) {
+    const { client, chain } = c.var
+
+    try {
+      yield `Depositing ${c.args.amount} tokens to wallet...`
+      const hash = await Pay.depositAndApprove(client, {
+        amount: parseUnits(c.args.amount),
+      })
+      yield `Waiting for tx ${hashLink(hash, chain)} to be mined...`
+      await waitForTransactionReceipt(client, {
+        hash,
+      })
+      yield `Deposit successful`
+      return
+    } catch (error) {
+      if (c.options.debug) {
+        console.error(error)
+      }
+      return c.error({
+        code: 'FAILED_TO_DEPOSIT',
+        message: (error as Error).message,
+      })
+    }
+  },
+})
+
+wallet.command('withdraw', {
+  description: 'Withdraw wallet funds from a pay account',
+  args: z.object({
+    amount: z.coerce.number().gt(0).describe('Amount of USDFC to withdraw'),
+  }),
+  options: globalOptions,
+  middleware: [contextMiddleware],
+  async *run(c) {
+    const { client, chain } = c.var
+
+    try {
+      yield `Withdrawing ${c.args.amount} USDFC from pay account...`
+      const hash = await Pay.withdraw(client, {
+        amount: parseUnits(c.args.amount),
+      })
+      yield `Waiting for tx ${hashLink(hash, chain)} to be mined...`
+      await waitForTransactionReceipt(client, {
+        hash,
+      })
+      yield `Withdrawal successful`
+      return
+    } catch (error) {
+      if (c.options.debug) {
+        console.error(error)
+      }
+      return c.error({
+        code: 'FAILED_TO_WITHDRAW',
+        message: (error as Error).message,
+      })
+    }
+  },
+})