Hello-World-AVS Example

Introduction to Hello-World-AVS

Hello-World-AVS represents a demonstration of a minimally viable AVS with comprehensive Exocore Network Integration. This project illustrates the integration of off-chain task execution into the operational commitments of operators, while also explain the relationship between this operational logic and the AVS contracts. The process encompasses off-chain computation, acquisition of signatures from multiple Operators, aggregation of these signatures on the exocore-chain, and culminates in the validation and recording of the resultant value on-chain within the Exocore ecosystem.

Prior to the AVS becoming available for use, the following prerequisite steps must occur:

1. Registration of Operators is completed

2. The AVS Smart Contract instance is constructed using our template and subsequently deployed on the Exocore chain

3. Operators proceed with their registration within the AVS

Hello-World-AVS Lifecycle Flow

Each request for two numbers to be summed undergoes the following process:

AVS Task Execution Details

The Automated Validation Service (AVS) follows a systematic process to ensure accurate task execution and validation:

1. Task Submission: The Task Generator uses avsWriter to submit tasks directly to the AVS contract as outlined in the ExoWriter interface specifications.

2. Event Emission: Once a task is received, the AVS contract emits an event detailing the computation required, such as summing two numbers.

3. Operator Monitoring: Registered operators actively monitor the AVS contract for emitted events. Upon detecting a task, operators compute the specified result, sign it using a BLS signature, and forward their signatures to the Aggregator.

4. Signature Aggregation: The Aggregator accumulates all individual signatures into one aggregated BLS signature. If the number of signatures reaches the quorum threshold, the aggregated signature is sent back to the AVS contract.

5. Verification and Acceptance: The AVS contract evaluates whether the quorum threshold is satisfied and if the aggregated signature is valid. Successfully passing both checks leads to the acceptance of the computed task result.

For more in-depth technical insights, including how to run a local simulation of the AVS process, you can explore the AVS Hello World Repository.

1. The Task Generator submits the task to be executed to the AVS contract via avsWriter.

   • The ExoWriter interface facilitates the writing communication between the off-chain AVS service and the AVS contract within the Exocore Chain. This interface is structured as follows

     type ExoWriter interface {
     	RegisterAVSToExocore(
     		ctx context.Context,
     		avsName string,
     		minStakeAmount uint64,
     		taskAddr gethcommon.Address,
     		slashAddr gethcommon.Address,
     		rewardAddr gethcommon.Address,
     		avsOwnerAddress []string,
     		assetIds []string,
     		avsUnbondingPeriod uint64,
     		minSelfDelegation uint64,
     		epochIdentifier string,
     		params []uint64,
     	) (*gethtypes.Receipt, error)
     
     	RegisterBLSPublicKey(
     		ctx context.Context,
     		name string,
     		pubKey []byte,
     		pubKeyRegistrationSignature []byte,
     		pubKeyRegistrationMessageHash []byte,
     	) (*gethtypes.Receipt, error)
     
     	CreateNewTask(
     		ctx context.Context,
     		name string,
     		taskResponsePeriod uint64,
     		taskChallengePeriod uint64,
     		thresholdPercentage uint64,
     		taskStatisticalPeriod uint64,
     	) (*gethtypes.Receipt, error)
     
     	OperatorSubmitTask(
     		ctx context.Context,
     		taskID uint64,
     		taskResponse []byte,
     		blsSignature []byte,
     		taskContractAddress string,
     		stage string,
     	) (*gethtypes.Receipt, error)
     
     	RegisterOperatorToExocore(
     		ctx context.Context,
     		metaInfo string,
     	) (*gethtypes.Receipt, error)
     
     	RegisterOperatorToAVS(
     		ctx context.Context,
     	) (*gethtypes.Receipt, error)
     }

   • The AVS task management process initiates the transmission of a new task to the Exocore chain for execution.

     // sendNewTask sends a new task to the task manager contract.
     func (avs *Avs) sendNewTask() error {
         avs.logger.Info("Avs sending new task")
         _, err := avs.avsWriter.CreateNewTask(
             context.Background(),
             GenerateRandomName(5),
             types.TaskResponsePeriod,
             types.TaskChallengePeriod,
             types.ThresholdPercentage,
             types.TaskStatisticalPeriod,
         )
         if err != nil {
             avs.logger.Error("Avs failed to sendNewTask", "err", err)
             return err
         }
         return nil
     }

2. The AVS contract subsequently emits an event signaling the successful creation of the task.

3. Operators monitor the AVS contract for the TaskCreated event through the ExoReader interface. Upon receiving this event, they execute the task, generate a BLS signature for the result, and subsequently transmit their signature to the Aggregator module on Exocore Chain for further processing.

   The ExoReader structure is defined as follows, providing a comprehensive interface for reading data from the Exocore Chain:

   type ExoReader interface {
   	GetOptInOperators(
   		opts *bind.CallOpts,
   		avsAddress string,
   	) ([]string, error)
   
   	GetRegisteredPubkey(
   		opts *bind.CallOpts,
   		operator string,
   	) ([]byte, error)
   	GtAVSUSDValue(
   		opts *bind.CallOpts,
   		avsAddress string,
   	) (sdkmath.LegacyDec, error)
   
   	GetOperatorOptedUSDValue(
   		opts *bind.CallOpts,
   		avsAddress string,
   		operatorAddr string,
   	) (sdkmath.LegacyDec, error)
   	GetAVSInfo(
   		opts *bind.CallOpts,
   		avsAddress string,
   	) (string, error)
   	GetTaskInfo(
   		opts *bind.CallOpts,
   		avsAddress string,
   		taskID uint64,
   	) ([]uint64, error)
   	IsOperator(
   		opts *bind.CallOpts,
   		operator string,
   	) (bool, error)
   
   	GetCurrentEpoch(
   		opts *bind.CallOpts,
   		epochIdentifier string,
   	) (int64, error)
   }

   }

4. The AVS module on the Exocore Chain consolidates individual operator signatures into a single aggregated signature utilizing BLS signature aggregation techniques. Once the quorum threshold is achieved and the aggregated signature is verified as valid, the Exocore chain's AVS module securely stores the task result signatures provided by participating operators, also stores the submitted task results by operators.

   

   AVS module on the Exocore Chain
5. During the challenge period, any external EOA address can call AVS's RaiseAndResolveChallenge precompiled method to challenge any operator's results.

Note the https://github.com/ExocoreNetwork/hello-world-avs includes specific links to source code files for additional information, you can visit it and run the local demo.