Add ZGComputeNetworkReadOnlyBroker (#164)

* Add ZGComputeNetworkReadOnlyBroker

* reconstruct

* less change

* update ci

Author: HONGJICAI

.github/workflows/cli-test.yml

@@ -86,16 +86,32 @@ jobs:
           # Test CLI commands using local binary
           if [ -f "./node_modules/.bin/0g-compute-cli" ]; then
             # npm/yarn classic with node_modules/.bin
+            echo "Testing basic CLI commands..."
             ./node_modules/.bin/0g-compute-cli --version
             ./node_modules/.bin/0g-compute-cli --help
             ./node_modules/.bin/0g-compute-cli inference --help
             ./node_modules/.bin/0g-compute-cli show-network || echo "Network command tested"
+
+            echo "Testing authentication-free commands..."
+            echo "→ Testing inference list-providers (no auth required)"
+            ./node_modules/.bin/0g-compute-cli inference list-providers --rpc https://evmrpc-testnet.0g.ai
+
+            echo "→ Testing inference list-providers-detail (no auth required)"
+            ./node_modules/.bin/0g-compute-cli inference list-providers-detail --rpc https://evmrpc-testnet.0g.ai
           elif [ "${{ matrix.pkg-manager }}" = "yarn" ]; then
             # yarn 4+ with PnP mode
+            echo "Testing basic CLI commands..."
             yarn run 0g-compute-cli --version
             yarn run 0g-compute-cli --help
             yarn run 0g-compute-cli inference --help
             yarn run 0g-compute-cli show-network || echo "Network command tested"
+
+            echo "Testing authentication-free commands..."
+            echo "→ Testing inference list-providers (no auth required)"
+            yarn run 0g-compute-cli inference list-providers --rpc https://evmrpc-testnet.0g.ai
+
+            echo "→ Testing inference list-providers-detail (no auth required)"
+            yarn run 0g-compute-cli inference list-providers-detail --rpc https://evmrpc-testnet.0g.ai
           else
             echo "CLI binary not found"
             exit 1

src.ts/cli/inference.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env ts-node
 
 import type { Command } from 'commander'
-import { withBroker, neuronToA0gi, a0giToNeuron, initBroker } from './util'
+import { withBroker, withROBroker, neuronToA0gi, a0giToNeuron, initBroker } from './util'
 import { getRpcEndpoint } from './network-setup'
 import { ensurePrivateKeyConfiguration } from './private-key-setup'
 import { interactiveSelect, textInput } from './interactive-selection'
@@ -78,12 +78,11 @@ export default function inference(program: Command) {
             '--include-invalid',
             'Include all services, even those without valid teeSignerAddress'
         )
-        .action((options: any) => {
+        .action(async (options: any) => {
             const table = new Table({
                 colWidths: [50, 50],
             })
-            withBroker(options, async (broker) => {
-                // TODO: Support pagination for listing services
+            await withROBroker(options, async (broker) => {
                 const services = await broker.inference.listService(
                     0,
                     50,
@@ -138,7 +137,7 @@ export default function inference(program: Command) {
     program
         .command('list-providers-detail')
         .description(
-            'List inference providers with health metrics (uptime and latency)'
+            'List inference providers with health metrics'
         )
         .option('--rpc <url>', '0G Chain RPC endpoint')
         .option('--ledger-ca <address>', 'Account (ledger) contract address')
@@ -147,12 +146,11 @@ export default function inference(program: Command) {
             '--include-invalid',
             'Include all services, even those without valid teeSignerAddress'
         )
-        .action((options: any) => {
+        .action(async (options: any) => {
             const table = new Table({
                 colWidths: [50, 50],
             })
-            withBroker(options, async (broker) => {
-                // TODO: Support pagination for listing services
+            await withROBroker(options, async (broker) => {
                 const services = await broker.inference.listServiceWithDetail(
                     0,
                     50,

src.ts/cli/network-setup.ts

@@ -153,7 +153,7 @@ export async function ensureNetworkConfiguration(): Promise<string> {
 /**
  * Gets the RPC endpoint, with interactive setup if needed
  */
-export async function getRpcEndpoint(options: any): Promise<string> {
+export async function getRpcEndpoint(options: { rpc?: string }): Promise<string> {
     // Priority: CLI option > environment variable > interactive setup
     if (options.rpc) {
         return options.rpc

src.ts/cli/util.ts

@@ -1,5 +1,5 @@
-import type { ZGComputeNetworkBroker } from '../sdk'
-import { createZGComputeNetworkBroker } from '../sdk'
+import type { ZGComputeNetworkBroker, ZGComputeNetworkReadOnlyBroker } from '../sdk'
+import { createZGComputeNetworkBroker, createZGComputeNetworkReadOnlyBroker } from '../sdk'
 import { ethers } from 'ethers'
 import chalk from 'chalk'
 import type { Table } from 'cli-table3'
@@ -46,6 +46,25 @@ export async function withBroker(
     }
 }
 
+/**
+ * Utility function for commands that only need read-only access (no authentication)
+ * Use this for listing providers, getting service info, etc.
+ */
+export async function withROBroker(
+    options: any,
+    action: (broker: ZGComputeNetworkReadOnlyBroker) => Promise<void>
+) {
+    try {
+        const rpcEndpoint = await getRpcEndpoint(options)
+        const broker = await createZGComputeNetworkReadOnlyBroker(rpcEndpoint)
+        await action(broker)
+        process.exit(0)
+    } catch (error: any) {
+        alertError(error)
+        process.exit(1)
+    }
+}
+
 export async function withFineTuningBroker(
     options: any,
     action: (broker: ZGComputeNetworkBroker) => Promise<void>

src.ts/sdk/broker.ts

@@ -1,92 +1,28 @@
 import type { JsonRpcSigner } from 'ethers'
-import { Wallet } from 'ethers'
+import { Wallet, JsonRpcProvider } from 'ethers'
 import { createLedgerBroker } from './ledger'
 import { createFineTuningBroker } from './fine-tuning/broker'
 import { createInferenceBroker } from './inference/broker/broker'
 import type { InferenceBroker } from './inference/broker/broker'
 import type { LedgerBroker } from './ledger'
 import type { FineTuningBroker } from './fine-tuning/broker'
+import { createReadOnlyInferenceBroker } from './inference/broker/read-only-broker'
+import type { ReadOnlyInferenceBroker } from './inference/broker/read-only-broker'
+import {
+    TESTNET_CHAIN_ID,
+    MAINNET_CHAIN_ID,
+    HARDHAT_CHAIN_ID,
+    CONTRACT_ADDRESSES,
+    isDevMode,
+} from './constants'
 
-// Network configurations
-export const TESTNET_CHAIN_ID = 16602n
-export const MAINNET_CHAIN_ID = 16661n
-export const HARDHAT_CHAIN_ID = 31337n
-
-// Contract addresses for different networks
-export const CONTRACT_ADDRESSES = {
-    testnet: {
-        ledger: '0xE70830508dAc0A97e6c087c75f402f9Be669E406',
-        inference: '0xa79F4c8311FF93C06b8CfB403690cc987c93F91E',
-        fineTuning: '0xC6C075D8039763C8f1EbE580be5ADdf2fd6941bA',
-    },
-    testnetDev: {
-        ledger: '0x815B93ab4Ba4BDF530dbF1552649a3c534F8BbF7',
-        inference: '0x41bD7Ac5c19000A974D5c192bcd5FB67b56C85c5',
-        fineTuning: '0x4e4158DF35CfdC0ac63264D3E112F5B8E9a5c569',
-    },
-    mainnet: {
-        ledger: '0x2dE54c845Cd948B72D2e32e39586fe89607074E3',
-        inference: '0x47340d900bdFec2BD393c626E12ea0656F938d84',
-        fineTuning: '0x4e3474095518883744ddf135b7E0A23301c7F9c0',
-    },
-    hardhat: {
-        ledger: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
-        inference: '0x0165878A594ca255338adfa4d48449f69242Eb8F',
-        fineTuning: '0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0',
-    },
-} as const
-
-/**
- * Check if dev mode is enabled
- * Supports multiple ways to enable dev mode:
- * - Node.js: ZG_DEV_MODE environment variable
- * - Next.js: NEXT_PUBLIC_ZG_DEV_MODE environment variable (build-time)
- * - Browser: localStorage 'ZG_DEV_MODE' = 'true'
- * - Browser: URL parameter ?dev=true or ?ZG_DEV_MODE=true
- */
-export function isDevMode(): boolean {
-    // Check Node.js / Next.js environment variables
-    if (typeof process !== 'undefined' && process.env) {
-        if (
-            process.env.ZG_DEV_MODE === 'true' ||
-            process.env.ZG_DEV_MODE === '1'
-        ) {
-            return true
-        }
-        if (
-            process.env.NEXT_PUBLIC_ZG_DEV_MODE === 'true' ||
-            process.env.NEXT_PUBLIC_ZG_DEV_MODE === '1'
-        ) {
-            return true
-        }
-    }
-
-    // Check browser localStorage and URL parameters
-    if (typeof window !== 'undefined') {
-        // Check localStorage
-        try {
-            const localStorageValue = window.localStorage.getItem('ZG_DEV_MODE')
-            if (localStorageValue === 'true' || localStorageValue === '1') {
-                return true
-            }
-        } catch {
-            // localStorage not available
-        }
-
-        // Check URL parameters
-        try {
-            const urlParams = new URLSearchParams(window.location.search)
-            const devParam =
-                urlParams.get('dev') || urlParams.get('ZG_DEV_MODE')
-            if (devParam === 'true' || devParam === '1') {
-                return true
-            }
-        } catch {
-            // URL parsing failed
-        }
-    }
-
-    return false
+// Re-export constants for backward compatibility
+export {
+    TESTNET_CHAIN_ID,
+    MAINNET_CHAIN_ID,
+    HARDHAT_CHAIN_ID,
+    CONTRACT_ADDRESSES,
+    isDevMode,
 }
 
 /**
@@ -229,3 +165,103 @@ export async function createZGComputeNetworkBroker(
         throw error
     }
 }
+
+/**
+ * Read-only version of ZGComputeNetworkBroker that doesn't require wallet connection.
+ * Provides access to public blockchain data without authentication.
+ *
+ * Use this broker to:
+ * - Browse available AI providers before connecting wallet
+ * - Fetch service information and pricing
+ * - Get provider health metrics
+ *
+ * Limitations:
+ * - Cannot perform authenticated operations (send requests, manage accounts, etc.)
+ * - No ledger or fine-tuning services (require authentication)
+ * - Read-only operations only
+ */
+export class ZGComputeNetworkReadOnlyBroker {
+    public inference!: ReadOnlyInferenceBroker
+
+    constructor(inferenceBroker: ReadOnlyInferenceBroker) {
+        this.inference = inferenceBroker
+    }
+}
+
+/**
+ * createZGComputeNetworkReadOnlyBroker creates a read-only broker WITHOUT wallet connection
+ *
+ * This broker provides access to public blockchain data (e.g., list providers) without
+ * requiring user authentication. Perfect for browsing services before connecting a wallet.
+ *
+ * @param rpcUrl - JSON-RPC endpoint URL (e.g., 'https://evmrpc-testnet.0g.ai')
+ * @param chainId - Optional chain ID. If not provided, will be detected from RPC endpoint.
+ *
+ * @returns Read-only broker instance with inference.listService() and inference.listServiceWithDetail()
+ *
+ * @example
+ * ```typescript
+ * // Create read-only broker (no wallet needed!)
+ * const broker = await createZGComputeNetworkReadOnlyBroker(
+ *   'https://evmrpc-testnet.0g.ai'
+ * );
+ *
+ * // List all available providers (no authentication required)
+ * const providers = await broker.inference.listService();
+ * console.log(`Found ${providers.length} providers`);
+ *
+ * // Get detailed provider info with health metrics
+ * const providersWithHealth = await broker.inference.listServiceWithDetail();
+ * providersWithHealth.forEach(p => {
+ *   console.log(`${p.provider}: ${p.healthMetrics?.uptime}% uptime`);
+ * });
+ * ```
+ *
+ * @throws An error if the broker cannot be initialized.
+ */
+export async function createZGComputeNetworkReadOnlyBroker(
+    rpcUrl: string,
+    chainId?: number
+): Promise<ZGComputeNetworkReadOnlyBroker> {
+    try {
+        // Create provider to detect network if chainId not provided
+        let detectedChainId = chainId
+        if (!detectedChainId) {
+            const provider = new JsonRpcProvider(rpcUrl)
+            const network = await provider.getNetwork()
+            detectedChainId = Number(network.chainId)
+        }
+
+        // Log detected network for debugging
+        const chainIdBigInt = BigInt(detectedChainId)
+        if (chainIdBigInt === MAINNET_CHAIN_ID) {
+            console.log(`Detected mainnet (chain ID: ${detectedChainId})`)
+        } else if (chainIdBigInt === TESTNET_CHAIN_ID) {
+            if (isDevMode()) {
+                console.log(
+                    `Detected testnet [DEV MODE] (chain ID: ${detectedChainId})`
+                )
+            } else {
+                console.log(`Detected testnet (chain ID: ${detectedChainId})`)
+            }
+        } else if (chainIdBigInt === HARDHAT_CHAIN_ID) {
+            console.log(`Detected hardhat (chain ID: ${detectedChainId})`)
+        } else {
+            console.warn(
+                `Unknown chain ID: ${detectedChainId}. Using testnet addresses as default.`
+            )
+        }
+
+        // Create read-only inference broker (no authentication!)
+        // The broker will auto-detect contract addresses based on chainId
+        const inferenceBroker = await createReadOnlyInferenceBroker(
+            rpcUrl,
+            detectedChainId
+        )
+
+        const broker = new ZGComputeNetworkReadOnlyBroker(inferenceBroker)
+        return broker
+    } catch (error) {
+        throw error
+    }
+}