Rewards and Penalties

Intro

Operators in a shared security environment are incentivized through rewards for making attestation and executing diverse specialized tasks. Rewards scale with the effective balance, which provides an economic incentive for Operators to behave honestly and act in the networks’ best interest.

To maximize reward, a single Operator opt-in to validate multiple networks, and puts its staked ETH at additional risk of penalties. Operators are penalized for missed, late or incorrect attestations. Violating a consensus rule of chain A, carries consequences on effective balance, which results in a lower reward and voting power on AVS B and C, alongside A.

Overview

Operator rewards depend both on the amount of base reward per task and the frequency at which an operator is chosen to perform a task. AVS developers must configure the task rewards and utilize a leader election mechanism to determine the frequency at which operators are selected for tasks. Othentic Stack allows the configuration of diverse types of tasks with different corresponding rewards.

Formalization

Stake-weighted Rewards

Most Proof-of-Stake networks include a "stake-weighted" Leader Election mechanism where the more stake an operator has the more tasks they'll be chosen to perform. The Othentic Stack supports any Leader Election mechanism implemented by the AVS developer.

When using a stake-weighted algorithm, for operator $n$, we denote the total reward $T_n$, with the expected value $E(T_n)$ described as:

$$E(T_n) = \frac{S_n}{S_{T}} \cdot C \cdot R$$

Where $R$ is the reward per task, $S_n$ is the effective balance of operator $n$, $S_T = \sum\limits_{n=1}^{N}S_n$ is the total effective stake for the network and $C$ is the number of tasks the network produced overall.

Generalization

To generalize for any Leader Election algorithm, a probability function $P(n)$ can be derived from the selected algorithm such that $\sum\limits_{n=1}^{N}P(n) = 1$ to rewrite the expected value formula as:

$$E(T_n) = E \Bigl( P(n) \Bigl) \cdot C \cdot R$$

For example, a uniformly random leader election mechanism — which is not stake-weighted — would have $P(n)=\frac{1}{N}$ .

Constructing the Rewards Function

There are two configurable components for the rewards function:

• $P(n)$ — The probability of operator $n$ to be elected for a task

• $R$ — The base reward for each task

$P(n)$ is derived from your Leader Election algorithm. Different algorithms could have different $P$ functions. $R$ is the base reward and is configurable via the AttestationCenter contract.

Configuring Base Rewards

Task Definitions

The Othentic Stack supports multiple types of tasks, called "Task Definition". Every Task Definition represents a certain type of task the network has to perform. A Task Definition includes the following properties:

Property	Type	Description
taskDefinitionId	uint16	Auto-generated incremental ID
name	string	A human-readable name for the task
blockExpiry	uint256	The block after which tasks of this type are no longer valid and will be rejected by the AttestationCenter
baseRewardFeeForAttesters	uint256	The base reward $R$ for the attester rewards function
baseRewardFeeForPerformer	uint256	The base reward $R$ for the performer rewards function
baseRewardFeeForAggregator	uint256	The base reward $R$ for the aggregator rewards function
disputePeriodBlocks	uint256	The amount of blocks needed to wait before payment can be finalized

Each task defines the base reward for each of the entities participating in consensus: the performer, the attesters, and the aggregators.

Creating Task Definitions

New Task Definitions are created on-chain via the AttestationCenter smart contract. See Attestation Center for more details on its API.

To create a new Task Definition, we invoke the createNewTaskDefinition() method:

Ethers

const attestationCenter = new ethers.Contract(
  ATTESTATION_CENTER_ADDRESS,
  ['function createNewTaskDefinition(string, uint256, uint256, uint256, uint256, uint256) external']
);

const tx = await attestationCenter.createNewTaskDefinition(
  "Example Task",             // Human-readable name
  ethers.MaxUint256,          // Never expires
  ethers.parseEther('0.01'),  // Reward for attestation
  ethers.parseEther('0.1'),   // Reward for performer
  ethers.parseEther('0.005'), // Reward for aggregation
  0                           // Disable disputes
);

await tx.wait();

Foundry

import { Script, console } from 'forge-std/Script.sol';

interface IAttestationCenter {
    function createNewTaskDefinition(
        string memory _name,
        uint256 _blockExpiry,
        uint256 _baseRewardFeeForAttesters,
        uint256 _baseRewardFeeForPerformer,
        uint256 _baseRewardFeeForAggregator,
        uint256 _disputePeriodBlocks
    ) external returns (uint16 _id);
}

contract CreateNewTask is Script {
    function run () external {
        IAttestationCenter attestationCenter = IAttestationCenter(ATTESTATION_CENTER_ADDRESS);

        uint16 taskId = attestationCenter.createNewTaskDefinition({
            _name: "Example Task",                    // Human-readable name
            _blockExpiry: type(uint256).max,          // Never expires
            _baseRewardFeeForAttesters: 0.01 ether,   // Reward for attestation
            _baseRewardFeeForPerformer: 0.1 ether,    // Reward for task
            _baseRewardFeeForAggregator: 0.005 ether, // Reward for aggregation
            _disputePeriodBlocks: 0                   // Disable disputes
        });

        console.log('New task ID: %s', taskId);
    }
}