Provider Quickstart

This guide covers everything you need to become a Pocket Network Provider and start earning POKT by serving blockchain data relays.

What Is a Provider?

A Provider runs Pocket Network infrastructure that serves blockchain API requests (relays) to applications. You stake POKT and run two components:

Full Node + RelayMiner — the relay-serving infrastructure that handles actual traffic
Igniter Provider — the operations platform that manages keys, staking workflows, delegators, and F-Chains collaboration with the foundation

Both are required. Igniter is mandatory for F-Chains participation and foundation collaboration.

1. Infrastructure Setup

Before deploying Igniter, you need the underlying relay-serving infrastructure.

Install pocketd

pocketd is the CLI for Pocket Network. It handles wallet management, staking transactions, and node operations.

Prerequisites:

Linux (x86_64, aarch64/arm64) or macOS (Darwin, x86_64, arm64)
curl
sudo access

bash

curl -sSL https://raw.githubusercontent.com/pokt-network/poktroll/main/tools/scripts/pocketd-install.sh | bash -s -- --tag latest

Verify:

bash

pocketd version

To upgrade an existing installation:

bash

curl -sSL https://raw.githubusercontent.com/pokt-network/poktroll/main/tools/scripts/pocketd-install.sh | bash -s -- --upgrade

For full installation options (Homebrew, manual binary, building from source), see the pocketd CLI section.

Create Wallets

You need two wallets for non-custodial staking (required for production):

Owner wallet — holds the staked POKT, receives rewards
Operator wallet — runs on the server, signs relay responses and claims/proofs

bash

# Create owner wallet (keep this seed phrase — offline backup required)
pocketd keys add owner-wallet --keyring-backend os

# Create operator wallet (this key will be on your server)
pocketd keys add operator-wallet --keyring-backend os

Danger

Back up both mnemonics immediately. The operator key lives on a server connected to the internet — if compromised, the attacker cannot steal staked funds (non-custodial design), but could disrupt your operations.

Get addresses:

bash

pocketd keys show owner-wallet -a
pocketd keys show operator-wallet -a

Install and Run a Full Node

The full node keeps the RelayMiner in sync with the blockchain and submits claims/proofs.

Prerequisites:

Linux only (macOS/Darwin is not supported by this script)
Root/sudo access
Dependencies: jq, curl, tar, wget, zstd, aria2c (script installs them automatically if you have apt-get, yum, or dnf)
200+ GB disk space (more for archival nodes)
Stable internet connection

The script will prompt for:

Network (testnet-alpha, testnet-beta, or mainnet)
Sync method: genesis (slow, verifies everything) or snapshot via torrent (faster, recommended)
Node moniker (default: hostname)
External IP address confirmation
Seeds confirmation
UFW firewall configuration (optional, opens port 26656)

bash

curl -sSL https://raw.githubusercontent.com/pokt-network/poktroll/main/tools/scripts/full-node.sh | bash

After setup, check the service status:

bash

sudo systemctl status cosmovisor-pocket.service

View logs:

bash

sudo journalctl -u cosmovisor-pocket.service -f

Verify sync:

bash

pocketd query block --type=height --network main

For full configuration options, see the pocketd CLI section.

Install and Run the RelayMiner

The RelayMiner receives relays from the network, forwards them to your backends, signs the responses, and submits the claims and proofs that get you paid. Use the HA RelayMiner, pocket-relay-miner. The single-process RelayMiner built into pocketd is legacy and no longer recommended.

It runs as two processes, a relayer and a miner, sharing one Redis. The quickest start is the repository’s Docker Compose example, which runs all three pointed at Beta TestNet.

Prerequisites:

Docker with Compose v2
Redis 8.10 or newer with maxmemory set and maxmemory-policy noeviction (the compose example provides it)
Your operator private key: pocketd keys export operator-wallet --unarmored-hex --unsafe
A backend node for every service you will stake on

bash

git clone --branch v0.1.0 https://github.com/pokt-network/pocket-relay-miner.git
cd pocket-relay-miner
docker pull ghcr.io/pokt-network/pocket-relay-miner:v0.1.0

Before serving, edit the example in examples/docker-compose/:

Put your operator key in config/supplier-keys.local.yaml and point both keys mounts in docker-compose.yaml at it. The shipped key is public and unstaked.
In config/relayer.yaml, add one entry under services for each service ID you will stake on, with the URL of its backend and an active health check:

yaml

services:
  eth:
    validation_mode: eager
    default_backend: jsonrpc
    backends:
      jsonrpc:
        urls:
          - "http://eth-node1:8545"
          - name: backup
            url: "http://eth-node2:8545"
        health_check:
          enabled: true
          endpoint: "/"
          method: "POST"
          request_body: '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'
          expected_body: '"result"'
          interval_seconds: 10
          timeout_seconds: 5
          unhealthy_threshold: 3
          healthy_threshold: 2

For MainNet, switch every value marked Mainnet: in config/relayer.yaml and config/miner.yaml, including the miner’s chain_id: pocket and block_time_seconds: 60.

Validate both configurations, then start:

bash

export C="docker compose -p pocket-supplier -f examples/docker-compose/docker-compose.yaml"
$C run --rm --no-deps miner miner validate --config /config/miner.yaml
$C run --rm --no-deps relayer relayer validate --config /config/relayer.yaml --check-stake
$C up -d

Put a TLS reverse proxy in front of the relayer and stake its https:// hostname as your endpoint. The full walkthrough, every configuration key, and the troubleshooting table are on RelayMiner Setup.

2. Deploy Igniter Provider

Igniter is the operations platform for managing your Provider. It handles:

Supplier key lifecycle (import, stake, unstake)
Relay miner and address group configuration
Delegator revenue sharing
F-Chains configuration for foundation collaboration

Info

Igniter is mandatory for F-Chains participation and any formal collaboration with Pocket Network Foundation. It does not replace the full node or RelayMiner — it sits on top as the management layer.

Prerequisites

Docker and Docker Compose
A domain name for the Provider admin UI
PostgreSQL (self-hosted or cloud-managed)
Temporal server (self-hosted or Temporal Cloud)
The infrastructure setup from Step 1 already running

Register as a Provider

Submit a PR to pokt-network/igniter-governance:

json

{
  "name": "<your-company-name>",
  "identity": "<your-secp256k1-hex-public-key>",
  "identityHistory": [],
  "url": "<your-provider-url>"
}

Place your JSON in the correct network folder (pocket-beta/ for testnet, pocket/ for mainnet). After the PR is merged, your Provider is registered and can receive delegations.

Deploy with Docker Compose

Clone the Igniter repo:

bash

git clone https://github.com/pokt-network/igniter.git
cd igniter

Start dependencies first:

bash

cd docker-compose/dependencies
cp .env.sample .env
# Edit .env — set a strong POSTGRES_PASSWORD
docker compose up -d

Start the Provider app:

bash

cd ../apps/provider
cp .env.sample .env

Edit .env:

bash

# === Required ===
TEMPORAL_URL=temporal:7233
TEMPORAL_NAMESPACE=provider
TEMPORAL_TASK_QUEUE=provider-operations

PGHOST=postgresql
PGUSER=igniter
PGPASSWORD=<same-as-dependencies-env>
DB_NAME=provider

POKT_RPC_URL=https://sauron-rpc.infra.pocket.network
CHAIN_ID=pocket
BLOCKCHAIN_PROTOCOL=shannon
OWNER_IDENTITY=pokt1your-owner-address
OWNER_EMAIL=ops@example.com
APP_IDENTITY=<hex-private-key-for-signing>
APP_URL=https://your-provider-domain.com

# === Generate these ===
ENCRYPTION_IV=$(openssl rand -hex 16)
ENCRYPTION_KEY=$(openssl rand -hex 32)
AUTH_SECRET=$(openssl rand -hex 24)

bash

docker compose up -d

Bootstrap Wizard

Access the Provider admin UI at APP_URL/admin/setup. Sign in with the wallet matching OWNER_IDENTITY.

Walk through the 7-step wizard:

Blockchain — Pocket RPC/API endpoints, chain ID
Identity — Provider name, reward addresses
Regions — Geographic locations for your miners (e.g., us-east, eu-west)
Relay Miners — Register each miner node with its domain
Services — Select on-chain services to serve (e.g., eth, arb-one, osmosis)
Address Groups — Link miners to services, configure revenue shares
Delegators — Enable Middleman instances allowed to stake with you

3. Configure F-Chains (PNF Collaboration)

F-Chains is Pocket Network Foundation’s program to ensure coverage on long-tail chains. PNF stakes POKT as Applications for supported chains — generating relay sessions that registered Suppliers can earn from.

For F-Chains Participation

When configuring Address Groups in the bootstrap wizard:

Create an Address Group for your F-Chains nodes
Enable Linked Addresses — this restricts staking to approved addresses only
Add the staker wallet addresses provided by PNF

This ensures only PNF can stake into this group, separating F-Chains subsidized traffic from public delegator traffic.

F-Chains II (Institutional Operators)

For large-scale subsidized operations under formal contract with PNF, contact directors@pokt.foundation.

For full details, see F-Chains.

4. Import and Stake Supplier Keys

After bootstrap, go to Keys in the Igniter sidebar to import supplier operator keys.

Igniter will:

Track key lifecycle states (imported → staked → unstaking)
Submit staking transactions via Temporal workflows
Monitor on-chain status and update key states

Stake as a Supplier

Ensure your operator wallet has:

Minimum stake: 59,500
Transaction fees for claims/proofs

Verify your Supplier status:

bash

pocketd query supplier show-supplier pokt1your-operator-address --network main

You should see status: "active" and your registered services.

5. Verify Relays and Rewards

Check the RelayMiner Is Serving

bash

$C exec relayer curl -s http://localhost:8081/ready/eth       # each backend's health for one service
$C exec miner pocket-relay-miner redis --config /config/miner.yaml submissions --supplier pokt1your-operator-address

The second command lists every claimed session with its claim and proof status.

Monitor your Supplier:

bash

pocketd query supplier show-supplier pokt1your-operator-address --network main

Check operator balance (must stay funded for proof submissions):

bash

pocketd query bank balance pokt1your-operator-address upokt --network main

Owner Staking Dashboard

Track all earnings: analytics.pocket.network/owner-staking

What to monitor:

Rewards over time — POKT earned, per address or aggregated
Settlement events — block, service, relays, and the amount settled vs. minted
Rewards by service — which chains generate the most revenue
Gaps in settlements — a service that stops settling is the signal to check your RelayMiner logs

Key Metric

Every required proof should land on-chain: ha_miner_proof_inclusion_outcome_total{outcome="on_chain_found"} should match the settled claims that required a proof. See Monitoring.

For full reward mechanics, see Supplier Rewards & Economics.

Common Service IDs

Service	Chain
`anvil`	Ethereum (local dev)
`eth`	Ethereum mainnet
`arb-one`	Arbitrum One
`base`	Base
`bsc`	BNB Smart Chain
`solana`	Solana
`poly`	Polygon
`osmosis`	Osmosis
`near`	Near
`ollama`	AI inference

Many services are not blockchains at all. Browse every service and its card at explorer.pocket.network/services, and see Services for what each card tells a supplier to run.

Next Steps

Supplier Staking — Owner-operator model, revenue sharing, unstake
RelayMiner Setup — Full configuration reference
RelayMiner Operations — Scaling, sizing, and metrics
Hardware Requirements — Infrastructure specs
Service Management — Add or remove services
F-Chains — PNF subsidized chains program
Igniter Provider docs — Full Igniter guides