Manual - OARN Network

🔬

For Researchers

Submit AI inference tasks to the decentralized compute network

Set Up Your Wallet

You'll need an Ethereum-compatible wallet to interact with OARN.

Option A: MetaMask (Recommended for beginners)

Install MetaMask browser extension
Create a new wallet and securely store your seed phrase
Add Arbitrum Sepolia network:
- Network Name: Arbitrum Sepolia
- RPC URL: https://sepolia-rollup.arbitrum.io/rpc
- Chain ID: 421614
- Currency: ETH
- Explorer: https://sepolia.arbiscan.io

Option B: Any Web3 Wallet

Rabby, Rainbow, or any wallet supporting Arbitrum works fine.

Get Testnet ETH

You need testnet ETH for gas fees on Arbitrum Sepolia.

Get Sepolia ETH from a faucet:
- sepoliafaucet.com
- Alchemy Sepolia Faucet
Bridge to Arbitrum Sepolia:
- Visit bridge.arbitrum.io
- Connect wallet and select Sepolia → Arbitrum Sepolia
- Bridge 0.1 ETH (takes ~10 minutes)

Prepare Your AI Model

Package your model for decentralized execution.

Supported Formats

ONNX - Recommended for cross-platform compatibility
PyTorch - .pt or .pth files
TensorFlow - SavedModel or .h5 format

Converting to ONNX

# PyTorch to ONNX
import torch
model = YourModel()
model.load_state_dict(torch.load('model.pt'))
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy_input, "model.onnx")

Upload to IPFS

Store your model and input data on the decentralized web.

Option A: Pinata (Easy)

Create account at pinata.cloud
Upload your model file
Copy the CID (e.g., QmXyz...)

Option B: IPFS CLI

# Install IPFS
curl -sSL https://dist.ipfs.tech/kubo/v0.24.0/kubo_v0.24.0_linux-amd64.tar.gz | tar -xz
sudo ./kubo/install.sh

# Add your file
ipfs add model.onnx
# Returns: added QmXyz... model.onnx

Submit a Task

Create and submit your compute task to the network.

Using the SDK

npm install @oarnnetwork/sdk

import { OARNClient, cidToBytes32 } from '@oarnnetwork/sdk';

const client = new OARNClient({
  privateKey: process.env.PRIVATE_KEY
});

// Upload model and input to IPFS, then convert CIDs to bytes32
const modelHash = cidToBytes32('QmYourModelCID...');
const inputHash = cidToBytes32('QmYourInputCID...');

const { taskId, tx } = await client.submitTask({
  modelHash,
  inputHash,
  rewardPerNode: 10000000000000000n, // 0.01 ETH
  requiredNodes: 3,
  deadline: Math.floor(Date.now() / 1000) + 3600
});

console.log('Task submitted:', taskId);

SDK available on npm and GitHub.

Direct Contract Interaction

Advanced users can interact directly with the TaskRegistryV2 contract:

Contract: 0xD15530ce13188EE88E43Ab07EDD9E8729fCc55D0
Function: submitTask(modelHash, inputHash, requirements, rewardPerNode, requiredNodes, deadline, consensusType)

Retrieve Results

Once a node completes your task, retrieve the output.

// Check task status
const task = await client.getTask(taskId);
console.log('Status:', task.status);

// Get result when complete
if (task.status === 'completed') {
  const result = await client.getResult(taskId);
  console.log('Output CID:', result.outputCid);

  // Download from IPFS
  const output = await ipfs.cat(result.outputCid);
}

Batch Tasks (Advanced)

Submit thousands of parameter combinations in a single task with 99.99% gas savings.

Generate Parameter Grid

import {
  OARNClient,
  generateParameterGrid,
  findOptimalByMetric
} from '@oarnnetwork/sdk';
import { parseEther } from 'ethers';

const client = new OARNClient({
  privateKey: process.env.PRIVATE_KEY
});

// Generate 10,000 parameter combinations
const inputs = generateParameterGrid({
  temperature: { min: 20, max: 40, steps: 100 },
  concentration: { min: 0.1, max: 1.0, steps: 100 }
});

console.log(`Generated ${inputs.length} combinations`);

Submit Batch Task

// Upload model and submit batch task
const modelBuffer = await fs.readFile('model.onnx');

const { taskId, manifestCid } = await client.submitBatchTask(
  modelBuffer,
  inputs,
  parseEther('0.1'),  // Reward per node
  5,                   // Required nodes
  Math.floor(Date.now() / 1000) + 86400  // 24h deadline
);

console.log('Batch task submitted:', taskId);
console.log('Manifest CID:', manifestCid);

Retrieve & Analyze Results

// Wait for consensus, then get results
const results = await client.getBatchResults(taskId);

if (results.consensusReached) {
  // Find optimal parameter combination
  const optimal = client.findOptimalResult(
    results.results, 'yield', 'max'
  );
  console.log('Best parameters:', optimal.output);

  // Get statistics
  const stats = client.getMetricStats(results.results, 'yield');
  console.log(`Yield: ${stats.mean} ± ${stats.stdDev}`);

  // Filter top performers
  const top10 = client.getTopResults(results.results, 'yield', 10);
}

Use Cases

Hyperparameter Search - Find optimal ML model parameters
Scientific Simulations - Test thousands of conditions
Drug Discovery - Screen molecular combinations
Materials Science - Optimize synthesis parameters

🖥️

For Node Operators

Run a compute node and earn COMP rewards for processing AI tasks

Check System Requirements

Ensure your system meets the minimum specifications.

Minimum Requirements

CPU	4 cores, 2.5GHz+
RAM	8 GB
Storage	50 GB SSD
Network	10 Mbps stable connection
OS	Linux (Ubuntu 22.04+), macOS, Windows 10+

Recommended (for better rewards)

CPU	8+ cores
RAM	32 GB
GPU	NVIDIA RTX 3060+ (8GB VRAM)
Storage	500 GB NVMe SSD
Network	100 Mbps+

Install Prerequisites

Install the required dependencies.

Linux (Ubuntu/Debian)

# Update system
sudo apt update && sudo apt upgrade -y

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Install build dependencies
sudo apt install -y build-essential pkg-config libssl-dev

# (Optional) Install NVIDIA drivers for GPU support
sudo apt install -y nvidia-driver-535

macOS

# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

Windows

# Install Rust from rustup.rs
# Download and run rustup-init.exe

# Install Visual Studio Build Tools
# Download from visualstudio.microsoft.com

Download & Build OARN Node

Get the node software from GitHub.

# Clone repository
git clone https://github.com/oarn-network/oarn-node.git
cd oarn-node

# Build release version
cargo build --release

# Verify installation
./target/release/oarn-node --version

Initialize Configuration

Set up your node configuration and wallet.

# Initialize node (creates config and wallet)
./target/release/oarn-node init

# This creates:
# ~/.oarn/config.toml - Node configuration
# ~/.oarn/keystore.json - Encrypted wallet

Edit Configuration

# Open config file
nano ~/.oarn/config.toml

Key Settings

[node]
mode = "standard"           # standard, validatorrouted, or local
port = 4001                 # P2P port

[compute]
max_concurrent_tasks = 2    # Tasks to run simultaneously
max_ram_mb = 8192          # RAM limit per task
max_vram_mb = 6144         # GPU VRAM limit
supported_frameworks = ["onnx", "pytorch"]

[wallet]
# Your wallet will be auto-generated
# Fund it with testnet ETH for gas

[privacy]
tor_enabled = false         # Enable for anonymity

Fund Your Node Wallet

Your node needs ETH for gas fees when claiming rewards.

# Display your node's wallet address
./target/release/oarn-node wallet address

# Output: 0x1234...5678

Send 0.05 testnet ETH to this address using the steps from the Researcher guide.

Start Your Node

Launch the node and begin accepting tasks.

# Start node in foreground
./target/release/oarn-node start

# Or run as background service (Linux)
sudo cp oarn-node.service /etc/systemd/system/
sudo systemctl enable oarn-node
sudo systemctl start oarn-node

# Check status
sudo systemctl status oarn-node

What You'll See

[INFO] OARN Node v0.1.0 starting...
[INFO] Wallet: 0x1234...5678
[INFO] Discovering network via ENS...
[INFO] Connected to 12 peers
[INFO] Listening on /ip4/0.0.0.0/tcp/4001
[INFO] Ready to accept tasks
[INFO] Capabilities: onnx, pytorch | RAM: 8GB | GPU: RTX 3060

Monitor & Earn

Track your node's performance and earnings.

# Check node status
./target/release/oarn-node status

# View earnings
./target/release/oarn-node wallet balance

# View completed tasks
./target/release/oarn-node tasks history

Maximizing Earnings

Uptime - Keep your node running 24/7
GPU - Nodes with GPUs earn more per task
Bandwidth - Faster connections = more tasks
Reliability - Complete tasks on time to build reputation

📈

For Investors

Understand the OARN ecosystem and participate in governance

Understand the Token Model

OARN uses a dual-token system for different purposes.

GOV Token (Governance)

Supply: 100,000,000 (Fixed)
Purpose: Voting, staking, protocol governance
Contract: 0xB97eDD49C225d2c43e7203aB9248cAbED2B268d3

GOV holders vote on protocol upgrades, fee structures, treasury allocation, and network parameters.

COMP Token (Compute)

Supply: Inflationary (decreasing emissions)
Purpose: Task rewards, payments
Contract: 0x24249A523A251E38CB0001daBd54DD44Ea8f1838

COMP is earned by node operators and spent by researchers. Optional 2% burn on transfers.

Set Up a Wallet

You need a wallet to hold and manage your tokens.

Recommended Wallets

Hardware (Most Secure): Ledger, Trezor
Browser: MetaMask, Rabby
Mobile: Rainbow, Trust Wallet

Add OARN Tokens to Wallet

Import custom tokens using these contract addresses:

GOV Token	`0xB97eDD49C225d2c43e7203aB9248cAbED2B268d3`
COMP Token	`0x24249A523A251E38CB0001daBd54DD44Ea8f1838`
Network	Arbitrum Sepolia (Testnet)

Acquire GOV Tokens

Get GOV tokens to participate in governance.

Current Phase: Testnet

OARN is currently on testnet. GOV tokens will be distributed at mainnet launch:

40% - Early compute contributors (airdrop)
30% - Public genesis sale
20% - DAO treasury
10% - Core team (4-year vesting)

How to Qualify for Airdrop

Run a compute node on testnet
Complete tasks successfully
Participate in community discussions
Report bugs and provide feedback

Participate in Governance

Use your GOV tokens to shape the protocol's future.

Governance Process

Discussion - Ideas shared on Discord/forum
Proposal - Formal proposal created (requires stake)
Voting - GOV holders vote (quadratic voting)
Execution - Passed proposals implemented

What You Can Vote On

Protocol upgrades and new features
Fee structures and reward rates
Treasury spending and grants
Network parameters (min stake, slashing)

Delegate Voting Power

// Delegate to yourself
await govToken.delegate(yourAddress);

// Or delegate to someone else
await govToken.delegate(delegateAddress);

Stake for Infrastructure

Stake GOV tokens to become an RPC provider or bootstrap node.

RPC Provider

Run blockchain RPC endpoints for the network.

Minimum Stake: 10,000 GOV
Rewards: Share of protocol fees
Risk: Slashing for downtime

Bootstrap Node

Help new nodes discover the P2P network.

Minimum Stake: 5,000 GOV
Rewards: Share of protocol fees
Risk: Slashing for unavailability

Register as Provider

// Approve GOV spending
await govToken.approve(registryAddress, stakeAmount);

// Register as RPC provider
await registry.registerRpcProvider(
  "https://your-rpc.example.com",
  stakeAmount
);

OARN Manual