@sentio/cli 3.5.1-rc.3 → 3.6.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/cli",
-  "version": "3.5.1-rc.3",
+  "version": "3.6.0-rc.1",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/commands/processor.ts

@@ -337,7 +337,7 @@ async function runProcessorResume(processorId: string | undefined, options: Proc
   })
 }
 
-async function runProcessorStop(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
+export async function runProcessorStop(processorId: string | undefined, options: ProcessorOptions & { yes?: boolean }) {
   const resolvedProcessorId = await resolveAndConfirmProcessor('stop', processorId, options)
   if (!resolvedProcessorId) return
   const context = createApiContext(options)

package/src/commands/stop-processor.ts

@@ -0,0 +1,63 @@
+import { Command } from '@commander-js/extra-typings'
+import chalk from 'chalk'
+import { handleCommandError } from '../api.js'
+import { confirm } from './upload.js'
+import { runProcessorStop } from './processor.js'
+import {
+  getSentioNetworkConfig,
+  resolveNetworkAddresses,
+  getWalletFromPrivateKey,
+  requirePrivateKey,
+  stopProcessorOnChain
+} from '../network.js'
+
+export function createStopProcessorCommand() {
+  return new Command('stop')
+    .description('Stop a processor. Uses Sentio Network contract when --sentio-network is specified.')
+    .argument('<processorId>', 'ID of the processor to stop')
+    .option('--sentio-network <network>', 'Stop via Sentio Network contract (only "testnet" supported)')
+    .option('--host <host>', 'Override Sentio host')
+    .option('--api-key <key>', 'Use an explicit API key instead of saved credentials')
+    .option('--token <token>', 'Use an explicit bearer token instead of saved credentials')
+    .option('--project <owner/slug>', 'Sentio project in <owner>/<slug> format')
+    .option('--owner <owner>', 'Sentio project owner')
+    .option('--name <name>', 'Sentio project name')
+    .option('-y, --yes', 'Bypass confirmation')
+    .showHelpAfterError()
+    .action(async (processorId, options) => {
+      try {
+        if (options.sentioNetwork) {
+          await runStopProcessorOnChain(processorId, options)
+        } else {
+          await runProcessorStop(processorId, options)
+        }
+      } catch (error) {
+        handleCommandError(error)
+      }
+    })
+}
+
+async function runStopProcessorOnChain(processorId: string, options: { sentioNetwork?: string; yes?: boolean }) {
+  const network = options.sentioNetwork!
+  const networkConfig = getSentioNetworkConfig(network)
+
+  const privateKey = requirePrivateKey()
+  const wallet = getWalletFromPrivateKey(privateKey)
+
+  console.log(chalk.blue(`Wallet address: ${wallet.address}`))
+  console.log(chalk.blue('Resolving contract addresses from AddressBook...'))
+  const addresses = await resolveNetworkAddresses(networkConfig)
+
+  if (!options.yes) {
+    const confirmed = await confirm(`Stop processor "${processorId}" on Sentio Network ${network}?`)
+    if (!confirmed) {
+      console.log('Stop cancelled.')
+      return
+    }
+  }
+
+  await stopProcessorOnChain(networkConfig, addresses, wallet, processorId)
+
+  console.log()
+  console.log(chalk.green(`Processor "${processorId}" stopped on Sentio Network ${network}.`))
+}

package/src/commands/upload.ts

@@ -13,6 +13,21 @@ import readline from 'readline'
 import JSZip from 'jszip'
 import { UserInfo } from '../../../protos/lib/service/common/protos/common.js'
 import { CommandOptionsType } from './types.js'
+import {
+  getSentioNetworkConfig,
+  resolveNetworkAddresses,
+  getWalletFromPrivateKey,
+  requirePrivateKey,
+  checkSTBalance,
+  checkBillingBalance,
+  uploadToIPFS,
+  createProcessorOnChain,
+  startProcessorOnChain,
+  stopProcessorOnChain,
+  confirmNoPlatformUpload,
+  getProcessorOnChain,
+  deleteProcessorOnChain
+} from '../network.js'
 import { Auth, DefaultBatchUploader, FileType, IPFSBatchUploader, WalrusBatchUploader } from '../uploader.js'
 export { type Auth } from '../uploader.js'
 
@@ -56,16 +71,164 @@ export function createUploadCommand() {
       '--required-chain-id <chain_id...>',
       '(Optional) Specify chain IDs required for the Sentio network. This option is only available when --sentio-network is used. If omitted, all chain IDs from the project configuration (contracts or network overrides) will be used.'
     )
+    .option(
+      '--no-platform',
+      'Upload processor directly to Sentio Network without platform support. Requires $PRIVATE_KEY env var. Only testnet is supported.'
+    )
+    .option(
+      '--ipfs-put-url <url>',
+      'IPFS upload endpoint (used with --no-platform)',
+      'https://api.sentio.xyz/v1/ipfs/add'
+    )
     .action(async (options, command) => {
       const processorConfig = loadProcessorConfig(options.path)
       overrideConfigWithOptions(processorConfig, options)
       if (options.path) {
         process.chdir(options.path)
       }
-      await runUploadInternal(processorConfig, options, command)
+      if (options.platform === false) {
+        await runNoPlatformUpload(processorConfig, options)
+      } else {
+        await runUploadInternal(processorConfig, options, command)
+      }
     })
 }
 
+async function runNoPlatformUpload(
+  processorConfig: YamlProjectConfig,
+  options: CommandOptionsType<typeof createUploadCommand>
+) {
+  // Determine network - default to testnet for --no-platform
+  const network = options.sentioNetwork || 'testnet'
+  const networkConfig = getSentioNetworkConfig(network)
+
+  // Step 1: Require PRIVATE_KEY
+  const privateKey = requirePrivateKey()
+  const wallet = getWalletFromPrivateKey(privateKey)
+  const walletAddress = wallet.address
+
+  // Step 2: Resolve contract addresses via AddressBook
+  console.log(chalk.blue('Resolving contract addresses from AddressBook...'))
+  const addresses = await resolveNetworkAddresses(networkConfig)
+
+  // Step 3: Check ST balance and Billing balance, then confirm
+  const [stBalance, billingBalance] = await Promise.all([
+    checkSTBalance(networkConfig, addresses, walletAddress),
+    checkBillingBalance(networkConfig, addresses, walletAddress)
+  ])
+  const confirmed = await confirmNoPlatformUpload(walletAddress, stBalance, billingBalance, addresses, networkConfig)
+  if (!confirmed) {
+    console.log('Upload cancelled.')
+    process.exit(0)
+  }
+
+  // Step 4: Build processor
+  if (!options.skipBuild) {
+    await buildProcessor(false, options)
+  }
+
+  const processorFile = path.join(process.cwd(), 'dist/lib.js')
+  if (!fs.existsSync(processorFile)) {
+    console.error(chalk.red('File not found:', processorFile, "- don't use --skip-build"))
+    process.exit(1)
+  }
+
+  const codeBuffer = fs.readFileSync(processorFile)
+  const stat = fs.statSync(processorFile)
+  console.log('Packed processor file size', Math.floor(stat.size / 1024) + 'K, last modified', stat.mtime)
+
+  // Step 5: Upload to IPFS
+  const ipfsPutUrl = options.ipfsPutUrl || 'https://api.sentio.xyz/v1/ipfs/add'
+  console.log(chalk.blue(`Uploading processor to IPFS (${ipfsPutUrl})...`))
+  const cid = await uploadToIPFS(codeBuffer, ipfsPutUrl)
+  console.log(chalk.green(`IPFS upload complete.`))
+  console.log('\t', chalk.blue('CID:'), cid)
+
+  // Step 6: Collect required chain IDs
+  let requiredChainIds = options.requiredChainId || processorConfig.requiredChainIds || []
+  if (requiredChainIds.length === 0) {
+    const chainIds = new Set<string>()
+    if (processorConfig.contracts) {
+      for (const contract of processorConfig.contracts) {
+        chainIds.add(String(contract.chain))
+      }
+    }
+    if (processorConfig.networkOverrides) {
+      for (const override of processorConfig.networkOverrides) {
+        chainIds.add(String(override.chain))
+      }
+    }
+    requiredChainIds = Array.from(chainIds)
+  }
+  if (requiredChainIds.length === 0) {
+    console.error(
+      chalk.red(
+        'Error: No chain IDs found. Specify --required-chain-id or define contracts/networkOverrides in sentio.yaml.'
+      )
+    )
+    process.exit(1)
+  }
+
+  // Step 7: Derive processor ID from project name
+  let processorId = processorConfig.project.replace('/', '_')
+  const sdkVersion = getSdkVersion() || 'unknown'
+
+  // Step 7.5: Check if processor already exists on-chain
+  console.log(chalk.blue('Checking if processor already exists on-chain...'))
+  const existingProcessor = await getProcessorOnChain(networkConfig, addresses, processorId)
+
+  if (existingProcessor) {
+    const existingOwner = existingProcessor.owner.toLowerCase()
+    const currentWallet = wallet.address.toLowerCase()
+
+    if (existingOwner === currentWallet) {
+      // Same owner — prompt to replace
+      console.log(chalk.yellow(`Processor "${processorId}" already exists (owned by you).`))
+      const shouldReplace = await confirm(`Replace existing processor "${processorId}"?`)
+      if (!shouldReplace) {
+        console.log('Upload cancelled.')
+        process.exit(0)
+      }
+      // Stop and delete existing processor before re-creating
+      await stopProcessorOnChain(networkConfig, addresses, wallet, processorId)
+      await deleteProcessorOnChain(networkConfig, addresses, wallet, processorId)
+    } else {
+      // Different owner — prompt to rename
+      console.log(
+        chalk.yellow(
+          `Processor "${processorId}" already exists and is owned by ${existingProcessor.owner} (not your wallet ${wallet.address}).`
+        )
+      )
+      const randomSuffix = Math.random().toString(36).substring(2, 8)
+      const defaultNewId = `${processorId}-${randomSuffix}`
+
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+      const newId: string = await new Promise((resolve) =>
+        rl.question(`Enter a new processor ID [${defaultNewId}]: `, (answer) => {
+          rl.close()
+          resolve(answer.trim() || defaultNewId)
+        })
+      )
+      processorId = newId
+      console.log(chalk.blue(`Using processor ID: ${processorId}`))
+    }
+  }
+
+  // Step 8: Create processor on-chain
+  await createProcessorOnChain(networkConfig, addresses, wallet, processorId, cid, requiredChainIds, sdkVersion)
+
+  // Step 9: Start processor on-chain
+  await startProcessorOnChain(networkConfig, addresses, wallet, processorId)
+
+  console.log()
+  console.log(chalk.green('=== Upload Complete ==='))
+  console.log('\t', chalk.blue('Processor ID:'), processorId)
+  console.log('\t', chalk.blue('IPFS CID:'), cid)
+  console.log('\t', chalk.blue('Network:'), network)
+  const codeHash = createHash('sha256').update(codeBuffer).digest('hex')
+  console.log('\t', chalk.blue('sha256:'), codeHash)
+}
+
 function parseCheckpoints(
   checkpoints: string[] | undefined,
   continueFrom: number | undefined,

package/src/index.ts

@@ -19,6 +19,7 @@ import { createPriceCommand } from './commands/price.js'
 import { createSimulationCommand } from './commands/simulation.js'
 import { createEndpointCommand } from './commands/endpoint.js'
 import { createDashboardCommand } from './commands/dashboard.js'
+import { createStopProcessorCommand } from './commands/stop-processor.js'
 import { enableApiDebug } from './api.js'
 import { printVersions } from './utils.js'
 
@@ -52,5 +53,6 @@ program.addCommand(createPriceCommand())
 program.addCommand(createSimulationCommand())
 program.addCommand(createEndpointCommand())
 program.addCommand(createDashboardCommand())
+program.addCommand(createStopProcessorCommand())
 
 program.parse()

package/src/network.ts

@@ -0,0 +1,407 @@
+import { ethers } from 'ethers'
+import chalk from 'chalk'
+import fetch from 'node-fetch'
+import readline from 'readline'
+
+// --- Network Configuration ---
+
+interface SentioNetworkConfig {
+  chainId: number
+  rpcUrl: string
+  explorerUrl: string
+  // AddressBook proxy that resolves all contract names to addresses
+  addressBookAddress: string
+}
+
+const TESTNET_CONFIG: SentioNetworkConfig = {
+  chainId: 7892101,
+  rpcUrl: 'https://testnet.sentio.xyz',
+  explorerUrl: 'https://testnet-explorer.sentio.xyz',
+  addressBookAddress: '0x17d5aF5Ed9C2558B802bEfcCc5a94C36dE95BB0B'
+}
+
+export function getSentioNetworkConfig(network: string): SentioNetworkConfig {
+  if (network === 'testnet' || network === '7892101') {
+    return TESTNET_CONFIG
+  }
+  if (network === 'mainnet' || network === '789210') {
+    console.error(chalk.red('Sentio Network mainnet is not yet supported. Only testnet is available.'))
+    process.exit(1)
+  }
+  console.error(chalk.red(`Invalid sentio network: ${network}. Only "testnet" is supported.`))
+  process.exit(1)
+}
+
+// --- Contract ABIs ---
+
+// AddressBook: resolves contract names to addresses
+const ADDRESS_BOOK_ABI = [
+  'function getAddress(string name) view returns (address)',
+  'function getAddress(bytes32 id) view returns (address)'
+]
+
+// ProcessorRegistry: createProcessor, getProcessor, deleteProcessor
+const PROCESSOR_REGISTRY_ABI = [
+  `function createProcessor(
+    string id,
+    tuple(uint8 sourceType, string ipfsCid) source,
+    tuple(string chainId, bool enableRpc, bool enableTrace)[] requireChains,
+    string sdkVersion
+  ) returns (string)`,
+  'event ProcessorCreated(string indexed processorId)',
+  'function getAllocations(string processorId) view returns (tuple(uint256 indexerId, uint256 timestamp, bool indexerReady)[])',
+  `function getProcessor(string processorId) view returns (
+    tuple(
+      string id,
+      bool active,
+      uint256 createdAt,
+      address owner,
+      string sdkVersion,
+      tuple(string chainId, bool enableRpc, bool enableTrace)[] requireChains,
+      tuple(uint8 sourceType, string ipfsCid) source,
+      tuple(uint256 indexerId, uint256 timestamp, bool indexerReady)[] allocations
+    )
+  )`,
+  'function deleteProcessor(string processorId)'
+]
+
+// Controller: startProcessor / stopProcessor
+const CONTROLLER_ABI = ['function startProcessor(string processorId)', 'function stopProcessor(string processorId)']
+
+// ERC20: balanceOf + approve
+const ERC20_ABI = [
+  'function balanceOf(address account) view returns (uint256)',
+  'function approve(address spender, uint256 amount) returns (bool)'
+]
+
+// Billing: deposit / depositTo / withdraw + balanceOf
+const BILLING_ABI = ['function balances(address account) view returns (uint256)']
+
+// --- Address Resolution via AddressBook ---
+
+// Known address book key names for the contracts we need
+const ADDRESS_BOOK_KEYS = {
+  processorRegistry: 'processor_registry',
+  controller: 'controller',
+  token: 'sentio_token',
+  billing: 'billing'
+} as const
+
+interface ResolvedAddresses {
+  addressBook: string
+  processorRegistry: string
+  controller: string
+  token: string
+  billing: string
+}
+
+let cachedAddresses: ResolvedAddresses | undefined
+
+export async function resolveNetworkAddresses(config: SentioNetworkConfig): Promise<ResolvedAddresses> {
+  if (cachedAddresses) return cachedAddresses
+
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const addressBookAddr = config.addressBookAddress
+
+  console.log(chalk.gray(`AddressBook: ${addressBookAddr}`))
+
+  const addressBook = new ethers.Contract(addressBookAddr, ADDRESS_BOOK_ABI, provider)
+
+  const resolveAddress = async (name: string): Promise<string> => {
+    try {
+      // Try string-based lookup first
+      return await addressBook['getAddress(string)'](name)
+    } catch {
+      try {
+        // Fallback to bytes32-based lookup (keccak256 of name)
+        const id = ethers.id(name)
+        return await addressBook['getAddress(bytes32)'](id)
+      } catch (e) {
+        throw new Error(`Failed to resolve "${name}" from AddressBook (${addressBookAddr}): ${e.message}`)
+      }
+    }
+  }
+
+  const [processorRegistry, controller, token, billing] = await Promise.all([
+    resolveAddress(ADDRESS_BOOK_KEYS.processorRegistry),
+    resolveAddress(ADDRESS_BOOK_KEYS.controller),
+    resolveAddress(ADDRESS_BOOK_KEYS.token),
+    resolveAddress(ADDRESS_BOOK_KEYS.billing)
+  ])
+
+  console.log(chalk.gray(`ProcessorRegistry: ${processorRegistry}`))
+  console.log(chalk.gray(`Controller:        ${controller}`))
+  console.log(chalk.gray(`ST Token:          ${token}`))
+  console.log(chalk.gray(`Billing:           ${billing}`))
+
+  cachedAddresses = { addressBook: addressBookAddr, processorRegistry, controller, token, billing }
+  return cachedAddresses
+}
+
+// --- Wallet Utilities ---
+
+export function getWalletFromPrivateKey(privateKey: string): ethers.Wallet {
+  if (!privateKey.startsWith('0x')) {
+    privateKey = '0x' + privateKey
+  }
+  return new ethers.Wallet(privateKey)
+}
+
+export function requirePrivateKey(): string {
+  const pk = process.env.PRIVATE_KEY
+  if (!pk) {
+    console.error(
+      chalk.red('Error: $PRIVATE_KEY environment variable is required for Sentio Network direct transactions.')
+    )
+    console.error(chalk.red('Set it with: export PRIVATE_KEY=0x...'))
+    process.exit(1)
+  }
+  return pk
+}
+
+export async function checkSTBalance(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  walletAddress: string
+): Promise<bigint> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const token = new ethers.Contract(addresses.token, ERC20_ABI, provider)
+  const balance: bigint = await token.balanceOf(walletAddress)
+  return balance
+}
+
+export async function checkBillingBalance(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  walletAddress: string
+): Promise<bigint> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const billing = new ethers.Contract(addresses.billing, BILLING_ABI, provider)
+  try {
+    const balance: bigint = await billing.balances(walletAddress)
+    return balance
+  } catch {
+    // Billing contract may revert for accounts that have never deposited
+    return 0n
+  }
+}
+
+// --- IPFS Upload ---
+
+export async function uploadToIPFS(fileBuffer: Buffer, ipfsUrl: string): Promise<string> {
+  const formData = new FormData()
+  const blob = new Blob([fileBuffer], { type: 'application/octet-stream' })
+  formData.append('file', blob, 'lib.js')
+
+  const response = await fetch(ipfsUrl, {
+    method: 'POST',
+    body: formData
+  })
+
+  if (!response.ok) {
+    const text = await response.text()
+    throw new Error(`IPFS upload failed: ${response.status} ${response.statusText} - ${text}`)
+  }
+
+  const result = (await response.json()) as { Hash: string }
+  return result.Hash
+}
+
+// --- Contract Interactions ---
+
+export interface OnChainProcessor {
+  id: string
+  active: boolean
+  createdAt: bigint
+  owner: string
+  sdkVersion: string
+}
+
+/**
+ * Fetch processor info from on-chain registry. Returns null if the processor does not exist.
+ */
+export async function getProcessorOnChain(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  processorId: string
+): Promise<OnChainProcessor | null> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const registry = new ethers.Contract(addresses.processorRegistry, PROCESSOR_REGISTRY_ABI, provider)
+
+  try {
+    const result = await registry.getProcessor(processorId)
+    // result is a tuple: (id, active, createdAt, owner, sdkVersion, requireChains, source, allocations)
+    const id: string = result[0]
+    if (!id || id === '') {
+      return null
+    }
+    return {
+      id,
+      active: result[1],
+      createdAt: result[2],
+      owner: result[3],
+      sdkVersion: result[4]
+    }
+  } catch {
+    // Contract reverts if processor doesn't exist
+    return null
+  }
+}
+
+export async function deleteProcessorOnChain(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  wallet: ethers.Wallet,
+  processorId: string
+): Promise<string> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const signer = wallet.connect(provider)
+
+  const registry = new ethers.Contract(addresses.processorRegistry, PROCESSOR_REGISTRY_ABI, signer)
+
+  console.log(chalk.blue('Deleting existing processor on-chain...'))
+  const tx = await registry.deleteProcessor(processorId)
+  console.log(chalk.gray(`  Tx hash: ${tx.hash}`))
+  console.log(chalk.blue('Waiting for confirmation...'))
+
+  const receipt = await tx.wait()
+  if (receipt.status === 0) {
+    throw new Error(`deleteProcessor transaction failed. Tx: ${config.explorerUrl}/tx/${tx.hash}`)
+  }
+
+  console.log(chalk.green(`Processor deleted. Tx: ${config.explorerUrl}/tx/${tx.hash}`))
+  return tx.hash
+}
+
+export async function createProcessorOnChain(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  wallet: ethers.Wallet,
+  processorId: string,
+  ipfsCid: string,
+  requiredChainIds: string[],
+  sdkVersion: string
+): Promise<string> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const signer = wallet.connect(provider)
+
+  const registry = new ethers.Contract(addresses.processorRegistry, PROCESSOR_REGISTRY_ABI, signer)
+
+  const source = {
+    sourceType: 0, // IPFS
+    ipfsCid
+  }
+
+  const requireChains = requiredChainIds.map((chainId) => ({
+    chainId,
+    enableRpc: true,
+    enableTrace: false
+  }))
+
+  console.log(chalk.blue('Creating processor on-chain...'))
+  console.log(chalk.gray(`  Processor ID: ${processorId}`))
+  console.log(chalk.gray(`  IPFS CID:     ${ipfsCid}`))
+  console.log(chalk.gray(`  Chains:        ${requiredChainIds.join(', ')}`))
+  console.log(chalk.gray(`  SDK Version:   ${sdkVersion}`))
+
+  const tx = await registry.createProcessor(processorId, source, requireChains, sdkVersion)
+  console.log(chalk.gray(`  Tx hash: ${tx.hash}`))
+  console.log(chalk.blue('Waiting for confirmation...'))
+
+  const receipt = await tx.wait()
+  if (receipt.status === 0) {
+    throw new Error(`createProcessor transaction failed. Tx: ${config.explorerUrl}/tx/${tx.hash}`)
+  }
+
+  console.log(chalk.green(`Processor created. Tx: ${config.explorerUrl}/tx/${tx.hash}`))
+  return tx.hash
+}
+
+export async function startProcessorOnChain(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  wallet: ethers.Wallet,
+  processorId: string
+): Promise<string> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const signer = wallet.connect(provider)
+
+  const controller = new ethers.Contract(addresses.controller, CONTROLLER_ABI, signer)
+
+  console.log(chalk.blue('Starting processor on-chain...'))
+  const tx = await controller.startProcessor(processorId)
+  console.log(chalk.gray(`  Tx hash: ${tx.hash}`))
+  console.log(chalk.blue('Waiting for confirmation...'))
+
+  const receipt = await tx.wait()
+  if (receipt.status === 0) {
+    throw new Error(`startProcessor transaction failed. Tx: ${config.explorerUrl}/tx/${tx.hash}`)
+  }
+
+  console.log(chalk.green(`Processor started. Tx: ${config.explorerUrl}/tx/${tx.hash}`))
+  return tx.hash
+}
+
+export async function stopProcessorOnChain(
+  config: SentioNetworkConfig,
+  addresses: ResolvedAddresses,
+  wallet: ethers.Wallet,
+  processorId: string
+): Promise<string> {
+  const provider = new ethers.JsonRpcProvider(config.rpcUrl)
+  const signer = wallet.connect(provider)
+
+  const controller = new ethers.Contract(addresses.controller, CONTROLLER_ABI, signer)
+
+  console.log(chalk.blue('Stopping processor on-chain...'))
+  const tx = await controller.stopProcessor(processorId)
+  console.log(chalk.gray(`  Tx hash: ${tx.hash}`))
+  console.log(chalk.blue('Waiting for confirmation...'))
+
+  const receipt = await tx.wait()
+  if (receipt.status === 0) {
+    throw new Error(`stopProcessor transaction failed. Tx: ${config.explorerUrl}/tx/${tx.hash}`)
+  }
+
+  console.log(chalk.green(`Processor stopped. Tx: ${config.explorerUrl}/tx/${tx.hash}`))
+  return tx.hash
+}
+
+// --- Confirmation Prompt ---
+
+export async function confirmNoPlatformUpload(
+  walletAddress: string,
+  stBalance: bigint,
+  billingBalance: bigint,
+  addresses: ResolvedAddresses,
+  networkConfig: SentioNetworkConfig
+): Promise<boolean> {
+  const formattedST = ethers.formatEther(stBalance)
+  const formattedBilling = ethers.formatEther(billingBalance)
+  console.log()
+  console.log(chalk.blue('=== Sentio Network Direct Upload (No Platform) ==='))
+  console.log(chalk.white(`  Address:         ${walletAddress}`))
+  console.log(chalk.white(`  ST Balance:      ${formattedST} ST`))
+  console.log(chalk.white(`  Billing Balance: ${formattedBilling} ST`))
+
+  if (billingBalance === 0n) {
+    console.log()
+    console.log(
+      chalk.yellow(
+        '  ⚠ Your Billing balance is 0. Indexing fees are charged from the Billing contract.\n' +
+          '    You must deposit ST tokens into the Billing contract before your processor can run.\n' +
+          `    Use: cast send ${addresses.token} "approve(address,uint256)" ${addresses.billing} <amount> --rpc-url ${networkConfig.rpcUrl} --private-key $PRIVATE_KEY\n` +
+          `         cast send ${addresses.billing} "deposit(uint256)" <amount> --rpc-url ${networkConfig.rpcUrl} --private-key $PRIVATE_KEY`
+      )
+    )
+  }
+  console.log()
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+  const answer: string = await new Promise((resolve) => rl.question('Continue with upload? (yes/no) ', resolve))
+  rl.close()
+  return ['y', 'yes'].includes(answer.toLowerCase())
+}