GrossFi docs

Introduction

GrossFi is an open-source decentralized compute protocol that coordinates AI inference workloads across a distributed network of GPU operators. The protocol is native to Robinhood Chain — an EVM-compatible Layer 2 with sub-cent transaction costs and 2-second finality.

Node operators stake $GROSS tokens as collateral. Honest computation is incentivized through per-task rewards. Fraudulent results trigger slashing, where a portion of the operator's stake is burned and redistributed.

Design Principles

Network Overview

The GrossFi network routes inference requests from clients to operators based on hardware capability, stake amount, and geographic latency. The routing layer is on-chain; the compute layer is off-chain with on-chain verification.

Participants

Request Lifecycle

1. Submission — Client broadcasts an inference request to the network with a specified model, input data, and max fee.
2. Routing — The protocol matches the request to an eligible operator based on stake tier, hardware capability, and latency.
3. Execution — Operator runs the model locally and submits the output along with a cryptographic proof.
4. Verification — Validator nodes spot-check the output. If it matches within tolerance, the task is marked verified.
5. Settlement — Payment is released to the operator in $GROSS. Gas costs are paid in ETH on Robinhood Chain.
6. Slashing (if applicable) — If verification fails, the operator's stake is slashed. A percentage is burned, the remainder goes to the validator who caught the fraud.

Robinhood Chain

GrossFi settles all staking, reward, and slashing events on Robinhood Chain mainnet. The chain was chosen for its low gas costs, EVM compatibility, and growing DeFi ecosystem.

Chain Parameters

Adding Robinhood Chain to Your Wallet

const params = {
  chainId: "0x7E9",
  chainName: "Robinhood Chain",
  nativeCurrency: {
    name: "Ether",
    symbol: "ETH",
    decimals: 18
  },
  rpcUrls: ["https://rpc.mainnet.chain.robinhood.com"],
  blockExplorerUrls: ["https://robinhoodchain.blockscout.com"]
};

// EIP-3085 wallet_addEthereumChain
await window.ethereum.request({
  method: "wallet_addEthereumChain",
  params: [params]
});

System Architecture

The protocol is split into three layers: the settlement layer (on-chain Robinhood Chain), the coordination layer (off-chain peer-to-peer network), and the compute layer (operator GPU hardware).

Settlement Layer

Smart contracts on Robinhood Chain handle staking, reward distribution, slashing, and governance. All value transfers are fully on-chain and auditable via the block explorer.

• StakingVault — Escrows operator stakes. Enforces minimum tier requirements. Handles slash and unstake operations.
• TaskRouter — Receives inference requests. Matches them to operators. Releases payment on verification.
• SlashingRegistry — Records verified fraud proofs. Burns slashed tokens, pays validator bounties.
• ModelRegistry — On-chain catalog of available models with hash references to weights stored on IPFS.
• Governance — $GROSS-weighted voting on protocol parameters: fee splits, slash rates, model listings.

Coordination Layer

A libp2p gossip network connects all operators and validators. Request broadcasting, proof submission, and peer discovery happen off-chain to minimize gas costs. Only the final settlement touches the chain.

• Peer discovery via Kademlia DHT
• Message propagation via Gossipsub
• Reputation scoring per peer
• NAT traversal via circuit relays

Compute Layer

Operators run the GrossFi client daemon, which listens for tasks, loads the relevant model, executes inference, and produces a proof. The daemon supports CUDA, ROCm, and Apple Silicon backends.

Proof of Inference

Proof of Inference is the protocol's consensus mechanism for verifying that an operator actually ran the requested computation. It is not a blockchain consensus algorithm — it is an application-layer verification scheme.

Challenge-Response Protocol

1. Challenge Generation — When a task is routed, the protocol generates a deterministic challenge derived from the model hash, input data, and a random nonce.
2. Execution — The operator runs the model and produces both the output and a proof artifact (intermediate layer activations for specific tokens).
3. Verification — Validator nodes re-run a subset of the computation (typically 5-10% of layers) and compare hash commitments.
4. Dispute Window — If a validator's re-computation differs from the operator's claim beyond tolerance, a slashing dispute is opened on-chain.

Spot-Check Frequency

Validators randomly spot-check ~15% of all tasks. Operators with higher historical accuracy are spot-checked less frequently (down to 5%), while new operators are checked more aggressively (up to 40% for the first 1,000 tasks).

Tech Stack

Node Tiers

Four operator tiers exist. Higher tiers require larger stakes and better hardware, but receive higher reward multipliers and priority routing.

Tier Selection Guidelines

• Edge Node — Best for hobbyists with consumer GPUs (RTX 3060, RX 6600, etc.). Runs quantized models (GGUF Q4/Q5). Lower throughput, but accessible entry point.
• Compute Node — For operators with datacenter-grade GPUs (RTX 4090, A5000, L40S). Runs full-precision inference. Eligible for priority task routing and enterprise workloads.
• Validator Node — Requires multiple GPUs in a cluster. Validators run inference and also verify other operators' work. Earns both task rewards and slashing bounties.
• Model Curator — For participants who want to contribute without operating hardware. Curators vote on which models are listed in the registry and earn a percentage of inference fees from models they support.

Staking & Rewards

Operators stake $GROSS into the StakingVault contract. The stake acts as collateral — if an operator produces fraudulent results, a portion is slashed. If they behave honestly, they earn rewards per verified task.

Reward Calculation

// Per-task reward formula
reward = baseFee × tierMultiplier × accuracyFactor × uptimeFactor

where:
  baseFee         = task-specific fee paid by client (in $GROSS)
  tierMultiplier  = {1.0, 2.5, 5.0} depending on node tier
  accuracyFactor  = historical accuracy (0.5 to 1.2)
  uptimeFactor    = rolling 7-day uptime (0.0 to 1.0)

Unstaking

Operators can request to unstake at any time. There is a 14-day unbonding period during which the stake remains slashable for any disputes arising from tasks completed before the unstake request. After the unbonding period, the full remaining stake is withdrawable.

Slashing Model

Slashing is the protocol's enforcement mechanism. When a validator proves that an operator submitted fraudulent results, the operator's stake is penalized.

Slash Schedule

Running a Node

This section covers the practical steps to register and operate a node on the GrossFi network.

Prerequisites

• A compatible GPU (8GB+ VRAM for Edge, 24GB+ for Compute)
• Robinhood Chain wallet with ETH for gas + $HHOD for staking
• Stable internet connection (minimum 50 Mbps upload)
• Linux or macOS (Windows via WSL2)
• NVIDIA CUDA 12.0+ or AMD ROCm 6.0+ (or Metal for Apple Silicon)

Installation

# Install the GrossFi client
curl -fsSL https://grossfi.com/install.sh | bash

# Verify installation
grossfi --version
# grossfi v1.0.0

Wallet Configuration

# Configure your Robinhood Chain wallet
grossfi config set-wallet \
  --address 0x80db...4fa3 \
  --chain-id 2025 \
  --rpc https://rpc.mainnet.chain.robinhood.com

# Approve $GROSS spending for StakingVault
grossfi approve --amount 11200000

Register & Stake

# Register as Edge Node (tier 1)
grossfi register \
  --tier edge \
  --stake 11200000 \
  --gpu cuda:0 \
  --model llama-3-8b-q4

# Start the daemon
grossfi start

# Check node status
grossfi status

Monitoring

The client exposes a metrics endpoint at http://localhost:9090/metrics (Prometheus format). Key metrics:

• grossfi_tasks_completed_total — Cumulative completed tasks
• grossfi_rewards_earned_gross — Total $GROSS earned
• grossfi_accuracy_rate — Rolling accuracy percentage
• grossfi_uptime_seconds — Continuous uptime
• grossfi_stake_current — Current staked balance

$GROSS Token

$GROSS is the native utility token of the GrossFi protocol. Fair-launched via Bankr on Robinhood Chain. Fixed max supply, zero buy/sell tax, and built-in swap fees that fund the protocol.

Token Properties

Token Utility

• Staking — Required to operate a node. Stake size determines tier and reward multiplier.
• Payment — Clients pay per-task inference fees in $GROSS. Fees are distributed to operators.
• Governance — $GROSS holders vote on protocol parameters, model listings, and treasury allocation.
• Swap Fees — 0.7% fee on every trade. 95% flows back to the protocol treasury, 5% to Bankr.

Supply Overview

The majority of supply enters circulation through Bankr's fair launch bonding curve. The creator allocation is locked for 30 days and vests linearly over 2 years — no team dumps. Swap fees accumulate in the protocol treasury and fund node rewards, development, and ecosystem growth.

API Reference

GrossFi exposes a REST API for clients who want to submit inference requests programmatically. The API is OpenAI-compatible for ease of integration.

Base URL

https://api.grossfi.com/v1

Submit Inference Request

POST /v1/completions
Content-Type: application/json
Authorization: Bearer <your-api-key>

{
  "model": "llama-3-8b",
  "prompt": "Explain proof of stake in one sentence.",
  "max_tokens": 100,
  "temperature": 0.7,
  "tier_preference": "compute",
  "max_fee": "1000000000000000000"
}

Response

{
  "id": "task_7f3a9b2c1e8d",
  "status": "completed",
  "model": "llama-3-8b",
  "output": "Proof of stake is a consensus mechanism...",
  "operator": "0x1234...5678",
  "verified": true,
  "verification_method": "spot_check",
  "fee_paid": "500000000000000000",
  "latency_ms": 1240,
  "timestamp": 1795234567
}

Endpoints

SDK & Tools

Official SDKs are available for JavaScript/TypeScript and Python. Both are thin wrappers around the REST API with type safety and retry logic.

JavaScript / TypeScript

npm install @grossfi/sdk

import { GrossFiClient } from "@grossfi/sdk";

const client = new GrossFiClient({
  apiKey: process.env.GROSSFI_API_KEY,
  chain: "robinhood"
});

const result = await client.inference.complete({
  model: "llama-3-8b",
  prompt: "What is decentralized compute?",
  maxTokens: 200
});

console.log(result.output);
console.log("Verified:", result.verified);
console.log("Fee:", result.feePaid, "GROSS");

Python

pip install grossfi

from grossfi import GrossFiClient

client = GrossFiClient(
    api_key=os.environ["GROSSFI_API_KEY"],
    chain="robinhood"
)

result = client.inference.complete(
    model="llama-3-8b",
    prompt="What is decentralized compute?",
    max_tokens=200
)

print(result.output)
print(f"Verified: {result.verified}")
print(f"Fee: {result.fee_paid} GROSS")

Smart Contracts

All contracts are written in Solidity 0.8.20+ and deployed on Robinhood Chain. Source code is verified on the block explorer.

Contract Registry

Security Model

Security is enforced through three layers: cryptographic verification (Proof of Inference), economic disincentives (staking + slashing), and governance controls (parameter updates via vote).

Threat Model

Bug Bounty

A bug bounty program will be launched alongside mainnet deployment. Rewards range from 1,000 $GROSS (low severity) to 500,000 $GROSS (critical). Details will be published on this page.

Audits

Smart contracts will undergo independent third-party audits before mainnet deployment. Audit reports will be published here.

Audit Scope

• GROSSToken (ERC-20 implementation)
• StakingVault (stake escrow, slash execution)
• TaskRouter (task routing, payment release)
• SlashingRegistry (fraud proof verification)
• ModelRegistry (model hash storage)
• Governance (voting, parameter updates)