Skip to main content

Relay Setup and Rewards

Relay fees are the only income an Orbinum validator earns. Ordinary transaction fees are burned by the runtime. A fee with no matching relay commit falls back to the block author; registering and committing is how you earn it as relayer rather than only in the slots you author.

Authoring alone still pays: a spend nobody committed to credits its fee to whoever included it. What registration and committing add is the ability to earn on operations you relay but do not author.

What you need is an ECDSA key of your own, inserted under the evmr key type. That key signs relay transactions, and its address is what you register on-chain — self-service, proving possession with a signature. Neither the address nor the key derives from your Aura mnemonic, so your relay identity is independent of your consensus key.

This is step 5, and it comes last

registerRelayer is rejected with NotValidator unless your account is already in the active set. Finish Apply to Join the Set first.

"Relayer" means two unrelated things

This page is about relay fees — the income a validator earns for including private transactions.

Orbinum also has a Hyperbridge relayer (Tesseract), which carries ISMP messages between chains and runs no Orbinum node at all. If you found a relayer/ directory in the deploy repo, that is the other one. The two share a word and nothing else.

Insert your relay key​

Generate an ECDSA key however you prefer — a wallet, subkey generate --scheme ecdsa, or an existing Ethereum key — and insert it into the node keystore:

docker exec orbinum-validator curl -s -H 'Content-Type: application/json' -d '{
  "jsonrpc":"2.0","id":1,"method":"author_insertKey",
  "params":["evmr","<your ecdsa mnemonic or seed>","<0x-prefixed public key>"]
}' http://localhost:9944

The call runs inside the container: 9944 is published on loopback only, and every key operation goes through docker exec.

The node rejects well-known development secrets (//Alice and friends) — they are public, so anyone could sign as you.

No evmr key means no relaying

The node still authors blocks without one — consensus is unaffected — but its relay does not sign, so it is never the paid relayer. This is logged at startup.

Get your address and proof​

Ask the node for both in one call:

docker exec orbinum-validator curl -s -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"relayer_getRelayInfo","params":[]}' \
  http://localhost:9944

It returns your EVM address and a secp256k1 signature over the binding digest for your account on this chain. Without an evmr key it explains what is missing instead of returning an address.

Register it yourself​

Submit relayer.registerRelayer(evmAddress, signature) signed by your validator account — not via sudo. Pass the values from relayer_getRelayInfo verbatim.

Rejections are listed under Errors; why the signature is required is in the pallet-relayer Reference.

Committing to a relay​

Since runtime spec 16, the fee follows a prior commitment, not the submitter. If you relay a spend without having committed to it first, the fee goes to the block author instead of you.

The sequence per operation:

  1. Derive the commit hash. Ask the runtime rather than building it yourself: shieldedPool_relayCommitHash(calldata, yourEvmAddress).
  2. Submit commit_relay(commits) — up to 64 hashes per call, so batch them.
  3. Wait. A commit recorded in the same block as the spend does not count. Poll relayer_relayCommitBlock(commit); once it returns a block below the current one, you are clear.
  4. Submit the spend.

Commits expire after 20 blocks, and each relay address may record at most 64 per block. A matching commit is consumed when the fee is credited, so one commit pays once.

On a tie — two relayers committing in the same block — the lowest commit hash wins. That is not grindable: the hash changes with every operation.

This is why relaying costs a transaction now

Earning the fee requires an extra call at least one block ahead. For a relayer handling a handful of operations, the commit can cost more than the fee returns; batching is what makes it pay at volume.

Relaying without committing still works and still executes the user's spend — you simply do not collect the fee unless you also authored the block.

Claiming accumulated fees​

Fees accumulate in PendingRelayerFees[AccountId][asset_id] as operations settle. Claiming pays them out to a public balance:

  • claim_relay_fees(asset_id, amount) — no proof, no note, no circuit
  • Signed origin, or relayed through the EVM precompile as claimRelayFees(assetId, amount)
  • The claim reveals your account and the amount; relayers are already public participants
  • Partial claims allowed; the remainder stays pending and does not expire

If you want the proceeds private, shield them afterwards like any other user.

See Gasless Fees for the full walkthrough.

Changing or losing your address​

To move to a different address: unregisterRelayer(), then registerRelayer with the new address and a fresh signature.

Leaving the validator set — by sudo removeValidator or your own deregisterValidator — clears the binding automatically. A binding must not outlive the membership that authorised it. Re-entering means registering again.

Fees you already earned survive. PendingRelayerFees is untouched by removal and stays claimable.