Skip to main content

Operators

Description

Operators are entities running infrastructure for decentralized networks within and outside of the Symbiotic ecosystem. The Symbiotic protocol creates a registry of operators, logs interactions with the protocol, and protocol participants can attach credentials and other data to operator entities. In the initial version, this encompasses operator entity metadata provided by the operators themselves, as well as data created by interacting with the Symbiotic protocol, such as:

  • Networks that the operator opted into
  • Associated vaults and restaked collateral from vaults
  • Historical logs of slashings and all other interactions with the Symbiotic ecosystem

An important benefit of the Symbiotic protocol and its enshrined vault system is the ability for operators to receive a stake from different partners (through vaults) to the same set of node infrastructure per supported network. This system allows node operators to acquire the stake from a diverse set of stakers with differing risk profiles without needing to set up isolated infrastructure for them.

operator-rel

In the future, we envision the Symbiotic protocol to contain a rich set of verifiable data and curated credentials about node operators. This will enable future networks using Symbiotic to source security for their use case to utilize innovative and maximally capital-efficient reputation-based operator selection mechanisms.

Technical overview

In Symbiotic, the operator can be either an EOA or a contract registered in the OperatorRegistry.

Vaults

To raise the stake, the operator must opt into networks and vaults by calling the optIn() method in the OperatorNetworkOptInService and OperatorVaultOptInService accordingly. The OPERATOR_NETWORK_LIMIT_SET_ROLE then allocates the stake to the operator by calling Vault.setOperatorNetworkLimit().

See Operator Limit Details.

Networks

The operator opts into the network to validate it. Based on various factors, such as reputation, stake amount, and other relevant criteria each network independently decides whether to include the operator in the active operator set or not.

Slashing

The operator's stake becomes active and subject to slashing immediately after the opt-in process to both the network and the vault. However, the corresponding role in the vault can apply the timelock for allocating a stake for additional guarantees for operators.

See Slashing Details.

Rewards

See Operator Rewards Details.

API reference

OperatorRegistry Interface

interface IOperatorRegistry {
/**
* @notice Emitted when an entity is added.
* @param entity address of the added entity
*/
event AddEntity(address indexed entity);

/**
* @notice Get if a given address is an entity.
* @param account address to check
* @return if the given address is an entity
*/
function isEntity(address account) external view returns (bool);

/**
* @notice Get a total number of entities.
* @return total number of entities added
*/
function totalEntities() external view returns (uint256);

/**
* @notice Get an entity given its index.
* @param index index of the entity to get
* @return address of the entity
*/
function entity(uint256 index) external view returns (address);

/**
* @notice Register the caller as an operator.
*/
function registerOperator() external;
}

OperatorOptInService Interface

interface IOperatorOptInService {
/**
* @notice Emitted when an operator opts into a "where" entity.
* @param operator address of the operator
* @param where address of the "where" entity
*/
event OptIn(address indexed operator, address indexed where);

/**
* @notice Emitted when an operator opts out from a "where" entity.
* @param operator address of the operator
* @param where address of the "where" entity
*/
event OptOut(address indexed operator, address indexed where);

/**
* @notice Get the operator registry's address.
* @return address of the operator registry
*/
function OPERATOR_REGISTRY() external view returns (address);

/**
* @notice Get the address of the registry where to opt-in.
* @return address of the "where" registry
*/
function WHERE_REGISTRY() external view returns (address);

/**
* @notice Check if a given operator is opted-in to a particular "where" entity.
* @param operator address of the operator
* @param where address of the "where" registry
*/
function isOptedIn(address operator, address where) external view returns (bool);

/**
* @notice Get the timestamp of the last opt-out of a given operator from a particular "where" entity.
* @param operator address of the operator
* @param where address of the "where" registry
*/
function lastOptOut(address operator, address where) external view returns (uint48);

/**
* @notice Check if a given operator was opted-in to a particular "where" entity after a given timestamp (inclusively).
* @param operator address of the operator
* @param where address of the "where" registry
* @param timestamp time point to check if the operator was opted-in after
*/
function wasOptedInAfter(address operator, address where, uint48 timestamp) external view returns (bool);

/**
* @notice Opt-in a calling operator to a particular "where" entity.
* @param where address of the "where" registry
*/
function optIn(address where) external;

/**
* @notice Opt-out a calling operator from a particular "where" entity.
* @param where address of the "where" registry
*/
function optOut(address where) external;
}