0g-orbit 0.1.0

package/packages/core/src/inference.ts

@@ -0,0 +1,256 @@
+import { Wallet } from 'ethers'
+import {
+    createZGComputeNetworkBroker,
+    type ZGComputeNetworkBroker,
+} from '@0glabs/0g-serving-broker'
+import type { NetworkConfig } from './networks.js'
+import type { InferResult, InferOptions, ServiceInfo } from './types.js'
+import { InferenceError, ProviderNotFoundError, TimeoutError } from './errors.js'
+import { withRetry } from './retry.js'
+
+const DEFAULT_LEDGER_DEPOSIT = 0.1 // 0.1 OG initial deposit
+const AUTO_FUND_INTERVAL = 30_000 // 30 seconds
+const DEFAULT_TIMEOUT = 30_000 // 30 seconds
+
+interface ChatCompletionResponse {
+    id?: string
+    model?: string
+    choices?: Array<{ message?: { content?: string } }>
+    usage?: {
+        prompt_tokens?: number
+        completion_tokens?: number
+        total_tokens?: number
+    }
+}
+
+export class InferenceClient {
+    private broker: ZGComputeNetworkBroker | null = null
+    private wallet: Wallet
+    private network: NetworkConfig
+    private initialized = false
+
+    constructor(network: NetworkConfig, wallet: Wallet) {
+        this.network = network
+        this.wallet = wallet
+    }
+
+    private async ensureBroker(): Promise<ZGComputeNetworkBroker> {
+        if (this.broker && this.initialized) return this.broker
+
+        try {
+            // Cast wallet to avoid ESM/CJS ethers type mismatch
+            this.broker = await createZGComputeNetworkBroker(
+                this.wallet as any,
+                this.network.ledgerContractAddress,
+                this.network.inferenceContractAddress,
+                this.network.fineTuningContractAddress
+            )
+            this.initialized = true
+            return this.broker
+        } catch (err: unknown) {
+            const msg = err instanceof Error ? err.message : String(err)
+            throw new InferenceError(
+                `Failed to initialize compute broker: ${msg}`,
+                'Check your network connection and wallet private key. The compute contracts may be temporarily unavailable.'
+            )
+        }
+    }
+
+    async listServices(): Promise<ServiceInfo[]> {
+        const broker = await this.ensureBroker()
+        return withRetry(
+            async () => {
+                try {
+                    const services = await broker.inference.listService()
+                    return services.map((s: any) => ({
+                        provider: s.provider ?? s.address ?? '',
+                        model: s.model ?? '',
+                        url: s.url ?? '',
+                        inputPrice: BigInt(s.inputPrice ?? 0),
+                        outputPrice: BigInt(s.outputPrice ?? 0),
+                        verifiable: Boolean(s.verifiability ?? s.verifiable),
+                    }))
+                } catch (err: unknown) {
+                    const msg = err instanceof Error ? err.message : String(err)
+                    throw new InferenceError(
+                        `Failed to list services: ${msg}`,
+                        'The inference contract may be temporarily unavailable. Check your network connection.'
+                    )
+                }
+            },
+            { maxAttempts: 3 }
+        )
+    }
+
+    async infer(
+        model: string,
+        options: InferOptions
+    ): Promise<InferResult> {
+        const broker = await this.ensureBroker()
+
+        // Find a provider for the requested model
+        const providerAddress = options.provider ?? await this.findProvider(model)
+        const timeout = options.timeout ?? DEFAULT_TIMEOUT
+
+        try {
+            // Ensure ledger exists and has funds
+            await this.ensureLedgerFunded(broker)
+
+            // Start auto-funding for this provider
+            await broker.inference.startAutoFunding(providerAddress, {
+                interval: AUTO_FUND_INTERVAL,
+            })
+
+            // Get service metadata (endpoint + model name)
+            const { endpoint, model: providerModel } =
+                await broker.inference.getServiceMetadata(providerAddress)
+
+            // Build the request content for billing calculation
+            const content = options.messages.map((m) => m.content).join('\n')
+
+            // Get authenticated headers
+            const headers = await broker.inference.getRequestHeaders(
+                providerAddress,
+                content
+            )
+
+            // Make the OpenAI-compatible request with timeout + retry
+            const data = await withRetry(
+                () => this.fetchCompletion(endpoint, providerModel, options, headers, timeout),
+                {
+                    maxAttempts: 2,
+                    baseDelay: 2000,
+                    isRetryable: (err) => {
+                        // Don't retry timeouts (user already waited long enough)
+                        if (err instanceof TimeoutError) return false
+                        // Retry transient provider errors
+                        if (err instanceof InferenceError) {
+                            const msg = err.message
+                            return msg.includes('502') || msg.includes('503') || msg.includes('504')
+                        }
+                        return false
+                    },
+                }
+            )
+
+            // Extract chatID for TEE verification
+            const chatID = data._chatID
+
+            // Process response (caches fees + verifies TEE signature)
+            let verified: boolean | null = null
+            try {
+                verified = await broker.inference.processResponse(
+                    providerAddress,
+                    chatID,
+                    data.usage ? JSON.stringify(data.usage) : undefined
+                )
+            } catch {
+                // Verification failure is non-fatal
+                verified = null
+            }
+
+            // Stop auto-funding
+            broker.inference.stopAutoFunding(providerAddress)
+
+            return {
+                content: data.choices?.[0]?.message?.content ?? '',
+                model: data.model ?? providerModel,
+                usage: data.usage
+                    ? {
+                          promptTokens: data.usage.prompt_tokens ?? 0,
+                          completionTokens: data.usage.completion_tokens ?? 0,
+                          totalTokens: data.usage.total_tokens ?? 0,
+                      }
+                    : undefined,
+                verified,
+            }
+        } catch (err) {
+            // Clean up auto-funding on error
+            broker.inference.stopAutoFunding(providerAddress)
+
+            if (err instanceof InferenceError || err instanceof TimeoutError || err instanceof ProviderNotFoundError) throw err
+            const msg = err instanceof Error ? err.message : String(err)
+            throw new InferenceError(`Inference failed: ${msg}`)
+        }
+    }
+
+    private async fetchCompletion(
+        endpoint: string,
+        providerModel: string,
+        options: InferOptions,
+        headers: Record<string, string> | object,
+        timeout: number
+    ): Promise<ChatCompletionResponse & { _chatID?: string }> {
+        const controller = new AbortController()
+        const timer = setTimeout(() => controller.abort(), timeout)
+
+        let response: Response
+        try {
+            response = await fetch(`${endpoint}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers,
+                },
+                body: JSON.stringify({
+                    model: providerModel,
+                    messages: options.messages,
+                    temperature: options.temperature,
+                    max_tokens: options.maxTokens,
+                }),
+                signal: controller.signal,
+            })
+        } catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                throw new TimeoutError(
+                    `Inference request timed out after ${timeout / 1000}s.`
+                )
+            }
+            throw err
+        } finally {
+            clearTimeout(timer)
+        }
+
+        if (!response.ok) {
+            const body = await response.text().catch(() => '')
+            throw new InferenceError(
+                `Provider returned ${response.status}: ${body}`,
+                response.status === 429
+                    ? 'Provider is rate-limited. Wait a moment and retry, or try a different provider.'
+                    : response.status >= 500
+                      ? 'The provider is experiencing issues. Try a different provider with the provider option.'
+                      : 'Check the model name and request parameters.'
+            )
+        }
+
+        const data = (await response.json()) as ChatCompletionResponse
+        const chatID = response.headers.get('ZG-Res-Key') ?? data.id ?? undefined
+
+        return { ...data, _chatID: chatID }
+    }
+
+    private async findProvider(model: string): Promise<string> {
+        const services = await this.listServices()
+        const match = services.find(
+            (s) => s.model.toLowerCase() === model.toLowerCase()
+        )
+        if (!match) {
+            const available = [...new Set(services.map((s) => s.model))].join(', ') || 'none'
+            throw new ProviderNotFoundError(
+                `No provider found for model "${model}". Available models: ${available}`
+            )
+        }
+        return match.provider
+    }
+
+    private async ensureLedgerFunded(
+        broker: ZGComputeNetworkBroker
+    ): Promise<void> {
+        try {
+            await broker.ledger.getLedger()
+        } catch {
+            // Ledger doesn't exist yet — create it with initial deposit
+            await broker.ledger.addLedger(DEFAULT_LEDGER_DEPOSIT)
+        }
+    }
+}

package/packages/core/src/networks.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest'
+import { getNetwork, NETWORKS } from './networks.js'
+
+describe('NETWORKS', () => {
+    it('testnet has correct chain ID', () => {
+        expect(NETWORKS.testnet.chainId).toBe(16602n)
+    })
+
+    it('mainnet has correct chain ID', () => {
+        expect(NETWORKS.mainnet.chainId).toBe(16661n)
+    })
+
+    it('testnet has multiple fallback RPC URLs', () => {
+        expect(NETWORKS.testnet.rpcUrls.length).toBeGreaterThanOrEqual(2)
+        expect(NETWORKS.testnet.rpcUrls[0]).toBe(NETWORKS.testnet.rpcUrl)
+    })
+
+    it('mainnet has multiple fallback RPC URLs', () => {
+        expect(NETWORKS.mainnet.rpcUrls.length).toBeGreaterThanOrEqual(2)
+        expect(NETWORKS.mainnet.rpcUrls[0]).toBe(NETWORKS.mainnet.rpcUrl)
+    })
+
+    it('all contract addresses are non-empty hex strings', () => {
+        for (const net of Object.values(NETWORKS)) {
+            expect(net.flowContractAddress).toMatch(/^0x[0-9a-fA-F]+$/)
+            expect(net.ledgerContractAddress).toMatch(/^0x[0-9a-fA-F]+$/)
+            expect(net.inferenceContractAddress).toMatch(/^0x[0-9a-fA-F]+$/)
+            expect(net.fineTuningContractAddress).toMatch(/^0x[0-9a-fA-F]+$/)
+        }
+    })
+})
+
+describe('getNetwork', () => {
+    it('resolves by name', () => {
+        const net = getNetwork('testnet')
+        expect(net.name).toBe('testnet')
+        expect(net.chainId).toBe(16602n)
+    })
+
+    it('resolves by chain ID', () => {
+        const net = getNetwork(16661n)
+        expect(net.name).toBe('mainnet')
+    })
+
+    it('throws on unknown name', () => {
+        expect(() => getNetwork('devnet' as any)).toThrow('Unknown network')
+    })
+
+    it('throws on unknown chain ID', () => {
+        expect(() => getNetwork(99999n)).toThrow('Unknown chain ID')
+    })
+
+    it('returns a copy — mutations do not affect originals', () => {
+        const net = getNetwork('testnet')
+        net.rpcUrl = 'https://mutated.example.com'
+        net.rpcUrls.push('https://extra.example.com')
+
+        const fresh = getNetwork('testnet')
+        expect(fresh.rpcUrl).not.toBe('https://mutated.example.com')
+        expect(fresh.rpcUrls).not.toContain('https://extra.example.com')
+    })
+})

package/packages/core/src/networks.ts

@@ -0,0 +1,62 @@
+export type NetworkName = 'testnet' | 'mainnet'
+
+export interface NetworkConfig {
+    name: NetworkName
+    chainId: bigint
+    rpcUrl: string
+    /** Fallback RPC URLs, tried in order if the primary fails */
+    rpcUrls: string[]
+    indexerUrl: string
+    flowContractAddress: string
+    ledgerContractAddress: string
+    inferenceContractAddress: string
+    fineTuningContractAddress: string
+}
+
+export const NETWORKS: Record<NetworkName, NetworkConfig> = {
+    testnet: {
+        name: 'testnet',
+        chainId: 16602n,
+        rpcUrl: 'https://evmrpc-testnet.0g.ai',
+        rpcUrls: [
+            'https://evmrpc-testnet.0g.ai',
+            'https://16600-rpc.testnet.0g.ai',
+            'https://og-testnet-evm-rpc.allthatnode.com',
+        ],
+        indexerUrl: 'https://indexer-storage-testnet-turbo.0g.ai',
+        flowContractAddress: '0xbD2C3F0E65eDF5582141C35969d66e34e4E6BF80',
+        ledgerContractAddress: '0xE70830508dAc0A97e6c087c75f402f9Be669E406',
+        inferenceContractAddress: '0xa79F4c8311FF93C06b8CfB403690cc987c93F91E',
+        fineTuningContractAddress: '0xC6C075D8039763C8f1EbE580be5ADdf2fd6941bA',
+    },
+    mainnet: {
+        name: 'mainnet',
+        chainId: 16661n,
+        rpcUrl: 'https://evmrpc.0g.ai',
+        rpcUrls: [
+            'https://evmrpc.0g.ai',
+            'https://0g-rpc-evm01.validatorvn.com',
+            'https://rpc.0g.thirdweb.com',
+        ],
+        indexerUrl: 'https://indexer-storage.0g.ai',
+        flowContractAddress: '0x0460aA47b41a66694c0a73f667a1b795A5ED3556',
+        ledgerContractAddress: '0x2dE54c845Cd948B72D2e32e39586fe89607074E3',
+        inferenceContractAddress: '0x47340d900bdFec2BD393c626E12ea0656F938d84',
+        fineTuningContractAddress: '0x4e3474095518883744ddf135b7E0A23301c7F9c0',
+    },
+}
+
+export function getNetwork(nameOrChainId: NetworkName | bigint): NetworkConfig {
+    if (typeof nameOrChainId === 'string') {
+        const config = NETWORKS[nameOrChainId]
+        if (!config) throw new Error(`Unknown network: ${nameOrChainId}`)
+        // Return a copy so overrides don't mutate the original
+        return { ...config, rpcUrls: [...config.rpcUrls] }
+    }
+    for (const config of Object.values(NETWORKS)) {
+        if (config.chainId === nameOrChainId) {
+            return { ...config, rpcUrls: [...config.rpcUrls] }
+        }
+    }
+    throw new Error(`Unknown chain ID: ${nameOrChainId}`)
+}

package/packages/core/src/orbit.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ConnectionError } from './errors.js'
+
+// Mock ethers before importing Orbit
+vi.mock('ethers', () => {
+    const mockProvider = {
+        getNetwork: vi.fn().mockResolvedValue({ chainId: 16602n }),
+        getBalance: vi.fn().mockResolvedValue(1000000000000000000n), // 1 OG
+    }
+    const MockJsonRpcProvider = vi.fn(() => mockProvider)
+    const MockWallet = vi.fn((key: string, provider: any) => ({
+        address: '0x1234567890abcdef1234567890abcdef12345678',
+        provider,
+    }))
+    return {
+        JsonRpcProvider: MockJsonRpcProvider,
+        Wallet: MockWallet,
+    }
+})
+
+// Mock the storage and inference clients
+vi.mock('./storage.js', () => ({
+    StorageClient: vi.fn(),
+}))
+vi.mock('./inference.js', () => ({
+    InferenceClient: vi.fn(),
+}))
+
+import { Orbit } from './orbit.js'
+import { JsonRpcProvider } from 'ethers'
+
+describe('Orbit.connect', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+        delete process.env.PRIVATE_KEY
+    })
+
+    it('connects with explicit private key', async () => {
+        const orbit = await Orbit.connect({
+            network: 'testnet',
+            privateKey: '0xabc123',
+        })
+        expect(orbit.address).toBe('0x1234567890abcdef1234567890abcdef12345678')
+        expect(orbit.network.name).toBe('testnet')
+    })
+
+    it('reads PRIVATE_KEY from env var', async () => {
+        process.env.PRIVATE_KEY = '0xenv_key_123'
+        const orbit = await Orbit.connect({ network: 'testnet' })
+        expect(orbit.address).toBeDefined()
+    })
+
+    it('throws with suggestion when no private key available', async () => {
+        await expect(
+            Orbit.connect({ network: 'testnet' })
+        ).rejects.toThrow('No private key provided')
+
+        try {
+            await Orbit.connect({ network: 'testnet' })
+        } catch (err) {
+            expect(err).toBeInstanceOf(ConnectionError)
+            expect((err as ConnectionError).suggestion).toContain('PRIVATE_KEY')
+        }
+    })
+
+    it('throws on chain ID mismatch', async () => {
+        const { JsonRpcProvider } = await import('ethers')
+        const mockProvider = new JsonRpcProvider() as any
+        mockProvider.getNetwork.mockResolvedValueOnce({ chainId: 99999n })
+
+        await expect(
+            Orbit.connect({ network: 'testnet', privateKey: '0xabc' })
+        ).rejects.toThrow('Chain ID mismatch')
+    })
+
+    it('warns on zero balance but still connects', async () => {
+        const { JsonRpcProvider } = await import('ethers')
+        const mockProvider = new JsonRpcProvider() as any
+        mockProvider.getNetwork.mockResolvedValueOnce({ chainId: 16602n })
+        mockProvider.getBalance.mockResolvedValueOnce(0n)
+
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+        const orbit = await Orbit.connect({
+            network: 'testnet',
+            privateKey: '0xabc',
+        })
+
+        expect(orbit).toBeDefined()
+        expect(warnSpy).toHaveBeenCalledWith(
+            expect.stringContaining('0 OG balance')
+        )
+        warnSpy.mockRestore()
+    })
+
+    it('tries fallback RPC URLs on connection failure', async () => {
+        const { JsonRpcProvider } = await import('ethers')
+
+        // First two URLs fail, third succeeds
+        let callCount = 0
+        ;(JsonRpcProvider as any).mockImplementation(() => {
+            callCount++
+            const provider = {
+                getNetwork: callCount < 3
+                    ? vi.fn().mockRejectedValue(new Error('ECONNREFUSED'))
+                    : vi.fn().mockResolvedValue({ chainId: 16602n }),
+                getBalance: vi.fn().mockResolvedValue(1000000000000000000n),
+            }
+            return provider
+        })
+
+        const orbit = await Orbit.connect({
+            network: 'testnet',
+            privateKey: '0xabc',
+        })
+        expect(orbit).toBeDefined()
+        expect(callCount).toBe(3)
+    })
+
+    it('throws when all RPC URLs fail', async () => {
+        const { JsonRpcProvider } = await import('ethers')
+        ;(JsonRpcProvider as any).mockImplementation(() => ({
+            getNetwork: vi.fn().mockRejectedValue(new Error('ECONNREFUSED')),
+        }))
+
+        await expect(
+            Orbit.connect({ network: 'testnet', privateKey: '0xabc' })
+        ).rejects.toThrow('Failed to connect to any RPC endpoint')
+    })
+})
+
+describe('Orbit.status', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+        // Restore default mock after tests that override JsonRpcProvider
+        const mockProvider = {
+            getNetwork: vi.fn().mockResolvedValue({ chainId: 16602n }),
+            getBalance: vi.fn().mockResolvedValue(1000000000000000000n),
+        }
+        ;(JsonRpcProvider as any).mockImplementation(() => mockProvider)
+    })
+
+    it('returns formatted balance and address', async () => {
+        const orbit = await Orbit.connect({
+            network: 'testnet',
+            privateKey: '0xabc',
+        })
+        const status = await orbit.status()
+        expect(status.network).toBe('testnet')
+        expect(status.address).toBe('0x1234567890abcdef1234567890abcdef12345678')
+        expect(status.balance).toMatch(/^\d+\.\d{6}$/)
+    })
+})

package/packages/core/src/orbit.ts

@@ -0,0 +1,159 @@
+import { Wallet, JsonRpcProvider } from 'ethers'
+import type { NetworkName, NetworkConfig } from './networks.js'
+import { getNetwork, NETWORKS } from './networks.js'
+import { StorageClient } from './storage.js'
+import { InferenceClient } from './inference.js'
+import type {
+    OrbitConfig,
+    StoreResult,
+    StoreOptions,
+    RetrieveOptions,
+    InferResult,
+    InferOptions,
+    ServiceInfo,
+    AccountStatus,
+} from './types.js'
+import { ConnectionError } from './errors.js'
+
+export class Orbit {
+    readonly network: NetworkConfig
+    readonly storage: StorageClient
+    readonly inference: InferenceClient
+    private wallet: Wallet
+    private provider: JsonRpcProvider
+
+    private constructor(
+        network: NetworkConfig,
+        wallet: Wallet,
+        provider: JsonRpcProvider
+    ) {
+        this.network = network
+        this.wallet = wallet
+        this.provider = provider
+        this.storage = new StorageClient(network, wallet)
+        this.inference = new InferenceClient(network, wallet)
+    }
+
+    /**
+     * Connect to the 0G network. This is the primary entry point.
+     *
+     * Tries the primary RPC URL first, then falls back to alternates.
+     * If privateKey is not provided, reads from PRIVATE_KEY env var.
+     */
+    static async connect(config: OrbitConfig): Promise<Orbit> {
+        // Resolve private key: explicit > env var
+        const privateKey = config.privateKey ?? process.env.PRIVATE_KEY
+        if (!privateKey) {
+            throw new ConnectionError(
+                'No private key provided.',
+                'Pass privateKey in config or set the PRIVATE_KEY environment variable. Example: PRIVATE_KEY=0x... npx tsx index.ts'
+            )
+        }
+
+        const networkConfig = getNetwork(config.network)
+
+        // Allow overrides
+        if (config.rpcUrl) networkConfig.rpcUrl = config.rpcUrl
+        if (config.indexerUrl) networkConfig.indexerUrl = config.indexerUrl
+
+        // Build candidate RPC URLs: explicit override first, then the fallback list
+        const rpcUrls = config.rpcUrl
+            ? [config.rpcUrl]
+            : networkConfig.rpcUrls
+
+        // Try each RPC URL until one connects
+        let lastError: Error | null = null
+        for (const url of rpcUrls) {
+            try {
+                const provider = new JsonRpcProvider(url)
+                const wallet = new Wallet(privateKey, provider)
+
+                const chainId = (await provider.getNetwork()).chainId
+                if (chainId !== networkConfig.chainId) {
+                    throw new ConnectionError(
+                        `Chain ID mismatch: expected ${networkConfig.chainId}, got ${chainId}`,
+                        `Your RPC endpoint is on a different network. Use the correct RPC URL for ${networkConfig.name}.`
+                    )
+                }
+
+                // Lock in the working URL
+                networkConfig.rpcUrl = url
+
+                // Check balance and warn if zero (non-blocking)
+                try {
+                    const balance = await provider.getBalance(wallet.address)
+                    if (balance === 0n) {
+                        console.warn(
+                            `[0G Orbit] Warning: wallet ${wallet.address} has 0 OG balance on ${networkConfig.name}. ` +
+                            `Get testnet tokens at https://faucet.0g.ai`
+                        )
+                    }
+                } catch {
+                    // Balance check failure is non-fatal
+                }
+
+                return new Orbit(networkConfig, wallet, provider)
+            } catch (err) {
+                // Chain ID mismatch is not a transient failure — don't try other URLs
+                if (err instanceof ConnectionError && err.message.includes('Chain ID mismatch')) {
+                    throw err
+                }
+                lastError = err instanceof Error ? err : new Error(String(err))
+            }
+        }
+
+        const tried = rpcUrls.join(', ')
+        throw new ConnectionError(
+            `Failed to connect to any RPC endpoint. Tried: ${tried}. Last error: ${lastError?.message ?? 'unknown'}`,
+            'All RPC endpoints are unreachable. Check your internet connection, or provide a custom RPC URL with the rpcUrl option.'
+        )
+    }
+
+    // --- Storage shortcuts ---
+
+    async store(filePath: string, options?: StoreOptions): Promise<StoreResult> {
+        return this.storage.store(filePath, options)
+    }
+
+    async storeData(
+        data: string | Buffer | Uint8Array,
+        options?: StoreOptions
+    ): Promise<StoreResult> {
+        return this.storage.storeData(data, options)
+    }
+
+    async retrieve(
+        rootHash: string,
+        outputPath: string,
+        options?: RetrieveOptions
+    ): Promise<void> {
+        return this.storage.retrieve(rootHash, outputPath, options)
+    }
+
+    // --- Inference shortcuts ---
+
+    async infer(model: string, options: InferOptions): Promise<InferResult> {
+        return this.inference.infer(model, options)
+    }
+
+    async listServices(): Promise<ServiceInfo[]> {
+        return this.inference.listServices()
+    }
+
+    // --- Account ---
+
+    async status(): Promise<AccountStatus> {
+        const balance = await this.provider.getBalance(this.wallet.address)
+        const balanceOG = Number(balance) / 1e18
+
+        return {
+            balance: balanceOG.toFixed(6),
+            network: this.network.name,
+            address: this.wallet.address,
+        }
+    }
+
+    get address(): string {
+        return this.wallet.address
+    }
+}