Skip to content
Available on private testnetTestnet: yesMainnet: Not availableSoftware: Core bad4a06ea · protocol pqwerai-v8-testnet/1Updated

Earn the IPFS storage reward

Network upgrade at block 68,961 (about 20 November 2026): IPFS reward v2

From block 68,961 the 5 % IPFS share goes to the IPFS reward v2 pool 0x16362198b0685B4a1d4C1f531B215C21568002b7 (deployed 18 November 2026 at block 51,860) instead of the v1 pool. v2 operators post a bond and must answer every round within 4 blocks; late, missing or wrong answers are slashed. If you run your own node, you need wallet 0.8.12 or later or Core f31a83ce5 or later before that block, or your node stops following the chain. See IPFS reward v2 below.

Testnet 20777: v1 from block 34,785

The ipfs-reward/v1 hard fork (owner decision 16 November 2026) starts at block 34,785. From then on the issuance split is 67 % PoW / 18 % PoS / 1 % founder / 9 % Quantum Reserve / 5 % IPFS storage. The IPFS reward pool is 0xC6E5a0E438536102DA3379e4caCEDA249d776D8f. Its rounds are 192 blocks (about 30 minutes) with a 96-block proof window. Rounds without proofs roll their budget over, so nothing is lost while the first operators join. The pool contract is unaudited test-network code (author review only).

Operators of IPFS Kubo nodes, alone or in an IPFS Cluster, keep network content available: model weights, contract artifacts and the documentation. From the fork block, every settled epoch sends 5 % of block issuance to the IPFS reward pool, taken from the PoW share. The split becomes 67 % PoW / 18 % PoS / 1 % founder / 9 % Quantum Reserve / 5 % IPFS; no extra supply is created.

How you earn it: proof of pinning

  1. The pool keeps a manifest of the content the network needs: each entry is a CID, its size and the Merkle root of its bytes in 1 KiB chunks.
  2. You register your node and declare which manifest entries you pin. The declaration counts from the next round.
  3. Every round (a fixed number of blocks), the pool challenges two random 1 KiB chunks of what you declared. The choice comes from the block hash at the start of the round, so nobody knows it in advance.
  4. Your agent reads those chunks from your own Kubo node and sends them with a Merkle path inside the proof window. The contract checks them against the manifest root.
  5. After the window, the round is settled. Every operator who proved receives round budget × your bytes / all proven bytes, paid to your payout address. If nobody proves in a round, its budget rolls over to the next one.

You earn by bytes held, not by number of nodes: one reward identity per operator enrolled in the operator directory.

What you need

  • A Kubo node with its RPC API on 127.0.0.1:5001, pinning manifest content (an IPFS Cluster peer can do the pinning; the reward is per Kubo node).
  • An operator key enrolled in the OperatorDirectory by the enrollment authority, with a little PQAI for gas.
  • A payout address (can be a wallet address you keep offline).
  • Python 3 with eth-account, eth-abi and cryptography, and a Core RPC endpoint.

Run the agent

# what a manifest entry looks like (the curator publishes these on the pool)
python -m storage.ipfs_reward manifest --kubo http://127.0.0.1:5001 --cid <CID>

# register, declare manifest entries 0 and 1, then answer every round, settle and claim
python -m storage.ipfs_reward agent --rpc <core RPC URL> --pool 0xC6E5a0E438536102DA3379e4caCEDA249d776D8f \
    --key-file ~/.pqwerai/ipfs-operator.key --payout <payout address> --holdings 0,1 \
    --cluster-peer <cluster peer ID, optional>

The agent refuses to declare content whose Merkle root its Kubo node cannot reproduce, answers each challenge with bytes read from Kubo at that moment, and never prints the key.

IPFS reward v2 (from block 68,961)

v2 keeps the same issuance rule (5 % of gross issuance per settled epoch, from the PoW share) and the same Merkle manifest format, so v1 content entries carry over. It changes which contract receives the share and how it pays (full specification: protocol/IPFS_REWARD_V2.md in the repository).

Parameter on 20777 Value
Pool 0x16362198b0685B4a1d4C1f531B215C21568002b7
First round block 68,961; rounds of 192 blocks (about 30 minutes)
Proof deadline 4 blocks after the round's seed block (about 35 seconds)
Challenges at least 8 per proof, and every holding is challenged every round (at most 32)
Bond 1 test PQAI per identity + 0.1 test PQAI per declared GiB
Penalty 5 % of the bond for a miss, rising with each consecutive miss; jailed after 3 in a row
Unbonding and payout changes take effect 48 rounds (about a day) later
Earning replicas at most 3 provers per content earn weight; extra provers share it
Identity gate none (directory = 0): the bond is the only one
Curator publisher key; manifest changes wait 9,300 blocks (about a day) and start the round after

The v1 backlog is moved into the v2 carry, and each proven round releases at most 1/48 of the carry on top of its own income, so early operators cannot take the whole backlog at once.

# bond, register, declare manifest entry 0, then answer every round within the deadline, settle and claim
python -m storage.ipfs_reward agent-v2 --rpc <core RPC URL> --pool 0x16362198b0685B4a1d4C1f531B215C21568002b7 \
    --key-file ~/.pqwerai/ipfs-operator.key --payout <payout address> --holdings 0 \
    --bond-margin-bps 2000 --keeper

# leave: move part of the bond to unbonding, or exit completely; withdraw after the unbonding delay
python -m storage.ipfs_reward unbond-v2 --rpc <core RPC URL> --pool 0x1636…02b7 --key-file <key> --amount <wei>
python -m storage.ipfs_reward unbond-v2 --rpc <core RPC URL> --pool 0x1636…02b7 --key-file <key> --exit
python -m storage.ipfs_reward withdraw-v2 --rpc <core RPC URL> --pool 0x1636…02b7 --key-file <key>

--bond-margin-bps 2000 keeps the bond 20 % above the requirement. --keeper also slashes other operators' unaccounted misses (slashes go to the reward carry, never to the curator). The agent polls every 2 seconds by default: keep it close to a fast Core RPC, because the deadline is only 4 blocks.

Proof of access, not proof of unique storage

v2 proves fast, reliable access to the declared bytes and makes failures expensive. It does not prove the bytes sit on your own disk: a node that can fetch the challenged chunks fast enough from elsewhere still passes. The income is small on the test network (about 0.0039 test PQAI per round at the recorded settlements); bonds and rewards are test PQAI with no monetary value.

Limits

  • Proof of pinning (v1) shows you produced the bytes inside the proof window; it does not prove where they were stored.
  • v1: the enrollment authority, not the contract, limits how many identities one operator can have. v2: every identity needs its own bond, and the replica cap limits what copies of one content can earn.
  • v2's round seed can still be re-rolled by the miner of the seed block withholding it (documented residual risk).
  • Both pool contracts are unaudited test-network code (author review only).

Found a problem? Report a documentation issue · Build testnet-rc1+7a33c77104