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

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())
+}

package/src/uploader.ts

@@ -89,7 +89,8 @@ export abstract class BatchUploader {
     debug?: boolean,
     continueFrom?: number,
     networkOverrides?: NetworkOverride[],
-    rollback?: Record<string, number>
+    rollback?: Record<string, number>,
+    initResponse?: InitBatchUploadResponse
   ): Promise<FinishBatchUploadResponse>
 
   async initUpload(fileTypes?: Record<string, FileType>): Promise<InitBatchUploadResponse> {
@@ -184,16 +185,18 @@ export class DefaultBatchUploader extends BatchUploader {
     debug?: boolean,
     continueFrom?: number,
     networkOverrides?: NetworkOverride[],
-    rollback?: Record<string, number>
+    rollback?: Record<string, number>,
+    initResponse?: InitBatchUploadResponse
   ): Promise<FinishBatchUploadResponse> {
-    // Step 1: Initialize upload with file types
-    const fileTypes: Record<string, FileType> = {
-      source: FileType.SOURCE,
-      code: FileType.PROCESSOR
+    // Step 1: Initialize upload with file types (if not already done)
+    if (!initResponse) {
+      const fileTypes: Record<string, FileType> = {
+        source: FileType.SOURCE,
+        code: FileType.PROCESSOR
+      }
+      initResponse = await this.initUpload(fileTypes)
     }
 
-    const initResponse = await this.initUpload(fileTypes)
-
     // Step 3: Upload files to S3 using presigned URLs
     for (const [fileKey, payload] of Object.entries(initResponse.payloads)) {
       if (!payload?.object?.putUrl) {
@@ -235,7 +238,7 @@ export class DefaultBatchUploader extends BatchUploader {
 
 export class IPFSBatchUploader extends BatchUploader {
   constructor(options: YamlProjectConfig, auth: Auth) {
-    super(StorageEngine.DEFAULT, options, auth)
+    super(StorageEngine.IPFS, options, auth)
   }
 
   async upload(
@@ -245,15 +248,17 @@ export class IPFSBatchUploader extends BatchUploader {
     debug?: boolean,
     continueFrom?: number,
     networkOverrides?: NetworkOverride[],
-    rollback?: Record<string, number>
+    rollback?: Record<string, number>,
+    initResponse?: InitBatchUploadResponse
   ): Promise<FinishBatchUploadResponse> {
-    const fileTypes: Record<string, FileType> = {
-      source: FileType.SOURCE,
-      code: FileType.PROCESSOR
+    if (!initResponse) {
+      const fileTypes: Record<string, FileType> = {
+        source: FileType.SOURCE,
+        code: FileType.PROCESSOR
+      }
+      initResponse = await this.initUpload(fileTypes)
     }
 
-    const initResponse = await this.initUpload(fileTypes)
-
     for (const [fileKey, payload] of Object.entries(initResponse.payloads)) {
       const putUrl = payload.object?.putUrl || payload.ipfs?.putUrl
       if (!putUrl) {
@@ -334,16 +339,18 @@ export class WalrusBatchUploader extends BatchUploader {
     debug?: boolean,
     continueFrom?: number,
     networkOverrides?: NetworkOverride[],
-    rollback?: Record<string, number>
+    rollback?: Record<string, number>,
+    initResponse?: InitBatchUploadResponse
   ): Promise<FinishBatchUploadResponse> {
-    // Step 1: Initialize upload with file types
-    const fileTypes: Record<string, FileType> = {
-      source: FileType.SOURCE,
-      code: FileType.PROCESSOR
+    // Step 1: Initialize upload with file types (if not already done)
+    if (!initResponse) {
+      const fileTypes: Record<string, FileType> = {
+        source: FileType.SOURCE,
+        code: FileType.PROCESSOR
+      }
+      initResponse = await this.initUpload(fileTypes)
     }
 
-    const initResponse = await this.initUpload(fileTypes)
-
     // Step 2: Create quilt multipart form data for all files
     const formData = this.createQuiltMultipartFormData(files)