Attestation Center

Overview

The Attestation Center allows diverse AVS functionalities and enables cost-effective, high-throughput task submissions while also serving as a verified data layer.

The Attestation Center is a critical system designed to ensure the integrity and efficiency of AVS operations by bridging off-chain execution with on-chain verification and maintaining a transparent history of all activities involved.

AVS Operators attest to the execution and validity of tasks through the consensus process. Operators claims are being recorded while the network comes to a consensus on arbitrary compute and auxiliary datasets, which allows the AVS to perform various functionalities on top of the verified results.

Key Details

Task submission and verification - allows AVS Operators to submit their off-chain tasks and verify them on-chain, ensuring that the tasks lifecycle can be tracked, recorded, and validated.

Rewards and penalties distribution - stores detailed information about individual Operator work, which allows the AVS protocol to calculate and distribute rewards, slashing, and penalties.

Aggregated view of AVS activities - maintains a comprehensive view and historical data of the AVS footprint, including all activities and tasks performed by the AVS.

Verified auxiliary datasets - As part of the task submission, Operators also agree on auxiliary info about the task and make it available on-chain (via the TaskInfo.data property). These datasets could be used to trigger AVS logic and complex mechanisms.

• For example, zk proofs can use the proofOfTask field for SNARK proofs while using the TaskInfo.data for public inputs and outputs to the circuit.

• For example, price oracle can be used TaskInfo.data as a timestamp for fetched data feeds.

Creation of new Tasks - configure diverse types of tasks with different corresponding rewards and penalties. You can also define a policy of bare requirements for specific clusters of operators.

Operator interface - interface for AVS Operators, facilitating their interaction with the system and allowing Operators to manage tasks, view history, and interact efficiently with the AVS.

AttestationCenter Functions

submitTask(TaskInfo calldata _taskInfo, bool _isApproved, bytes calldata _tpSignature, uint256[2] calldata _taSignature, uint256[] calldata _operatorIds) external 

Property	Type	Description
TaskInfo.taskDefinitionId	uint16	The ID of specific Task definition
TaskInfo.proofOfTask	string	ProofOfTask: any string that the Attesters can use to verify that the Performer has executed its task as expected.
TaskInfo.data	bytes	Any auxiliary/metadata required by the AVS or the service consumer to be verified.
TaskInfo.taskPerformer	address	The address of the Task Performer.
_isApproved	bool	Indicate if a task has been approved or rejected by the Attesters.
_tpSignature	bytes	Task Performer ECDSA signature.
_taSignature	uint256[2]	Task Attesters BLS aggregated signature.
_operatorIds	uint256[]	Task Attesters IDs

Creating Task Definitions

Not all Tasks are the same. You may have multiple Tasks you wish to execute, each with different parameters, corresponding rewards, and operator clusters. You can set the configuration of Tasks through Task Definition.

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,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
  0,                          // Minimum Voting Power
  []                          // Restricted Operator Set 
  }                          
);

await tx.wait();

Foundry

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

interface IAttestationCenter {
    struct TaskDefinitionParams {
        uint256 blockExpiry;
        uint256 baseRewardFeeForAttesters;
        uint256 baseRewardFeeForPerformer;
        uint256 baseRewardFeeForAggregator;
        uint256 disputePeriodBlocks;
        uint256 minimumVotingPower;
        uint256[] restrictedOperatorIndexes;
    }
    function createNewTaskDefinition(
        string memory _name,
        uint256 _blockExpiry,
        uint256 _baseRewardFeeForAttesters,
        uint256 _baseRewardFeeForPerformer,
        uint256 _baseRewardFeeForAggregator,
        uint256 _disputePeriodBlocks,
        uint256 _minimumVotingPower,
        uint256[] _restrictedOperatorIndexes
    ) 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
            _params: TaskDefinitionParams(
               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
               minimumVotingPower: 0                         // Minimum Voting Power
               restrictedOperatorIndexes: new uint256[](0)   // Restricted Operator Set
            )
        });

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

setTaskDefinitionMinVotingPower(uint16, uint256)

Set the minimum voting power for the task definition. Learn more here.

Parameter	Type	Description
_taskDefinitionId	uint16	Task Definition ID
_minimumVotingPower	uint256	Minimum Voting Power

setTaskDefinitionRestrictedOperators(uint16, uint256[])

Set the Restricted Operator set for the task definition. Learn more here.

Parameter	Type	Description
_taskDefinitionId	uint16	Task Definition ID
_restrictedOperatorIndexes	uint256[]	Restricted Operator Set