Delegation

Delegator is one of the three Vault modules responsible for handling the vault's funds allocation across networks and operators.

Its key functions are to:

• Allow networks to set the maximum amount of stake they are ready to get from the specific vault, so it determines the upper limit of the stake the module can return
• Handle the curator's stake allocations to networks and operators
• Aggregate all the data regarding the stake, including the deposited funds, networks' limits, allocations, and operators' opt-ins, and provide a calculated stake for any point in time

Technical overview

The Delegator module is responsible for the stake distribution logic. However, there can be different ways to handle this distribution (e.g., there are standard staking mechanics and more novel restaking ones). Hence, the Symbiotic core contracts' architecture allows the use of different types of Delegator (Symbiotic team can whitelist new types of Delegator depending on the demand). Currently, there are four types implemented (position indexes in the list below correspond to the on-chain types):

0. NetworkRestakeDelegator
1. FullRestakeDelegator
2. OperatorSpecificDelegator
3. OperatorNetworkSpecificDelegator

Each type differs from the others in the way the stake is distributed across networks and operators. However, there are some common details for all of them:

• The stake can be returned given any network's and any operator's addresses for any point in time
• The stake always depends on:
  • the vault's active stake (non-withdrawn funds)
  • the operator's opt-ins to the vault and the network
  • the limit set by the network, meaning the amount of stake it is ready to get from the vault
• There is a common handling of slashing events with the use of a hook (read more)

0. NetworkRestakeDelegator

The main goal of this type is to allow restaking across multiple networks but restrict operators from being restaked within the same network. Hence, from the network perspective, the operators' stakes don't affect each other in case of the need for slashing.

Its use case is to simplify the workflow for LRT providers or vault curators whose business is to raise and allocate funds to operators rather than to operate themselves.

To allocate the stake for a network, the vault curator should:

• Set a limit (allocation) for the network (it has to be less than or equal to the maximum limit set by the network)
• Set shares for each needed operator (the shares are converted to the percentage by dividing them by the total amount of set shares)

warning

After slashing, none of the Delegator types changes the limits of networks and operators. This logic can be added using the hook.

After that, the resulting stake of the operator inside the network, if the operator is opted-in to the vault and the network, will be calculated as follows:

$$\text{stake} = \frac{\min(\text{activeStake}, \text{networkLimit}) \times \text{shares}_{\text{op}}} {\sum_i \text{shares}_i}$$

1. FullRestakeDelegator

It allows restaking across multiple networks and operators simultaneously. Therefore, it might not be the best choice for networks to accept such vaults, as the actual amount of the operators' stake can be much less than the return by this type of Delegator.

It exists to allow the convenient implementation of an insurance mechanism, e.g., where the funds in such a vault defend the funds of all other vaults, so there is no difference if the particular operator is slashed and on which amount.

The vault curator can allocate the funds by:

• Setting a limit for the network (the same as for NetworkRestakeDelegator)
• Setting a limit for each needed operator

The stake's calculation, besides the opt-in checks mentioned earlier:

$$\text{stake} = \min(\text{activeStake}, \text{networkLimit}, \text{operatorLimit})$$

2. OperatorSpecificDelegator

OperatorSpecificDelegator is a simplified version of the NetworkRestakeDelegator, where only a single operator can operate. Hence, the use case of this Delegator type is pretty straightforward - allow operators to have their own vaults while enabling restaking.

Generally, these vaults are more secure for networks than those with the NetworkRestakeDelegator, as the operators' stake allocations can be adjusted only by themselves. At the same time, in the worst case of NetworkRestakeDelegator, the curator can use the operators' influence to attract the funds and use them for an attack.

The allocation process in this case is more compact than the previously described ones:

• Set a limit for the network (there is no need for any limits for operators as there is only a single one)

So, the stake calculation is:

$$\text{stake} = \min(\text{activeStake}, \text{networkLimit})$$

3. OperatorNetworkSpecificDelegator

It is the most simplified type of the Delegator and the most secure from the network's perspective. It represents a common staking mechanism with only a single network and a single operator (there still can be multiple vaults, so multiple operators for the network).

The networks can prioritize the vaults with such a Delegator type if they don't want to depend on others via restaking at all or want at least some share of their operators set to have strong economic security guarantees.

There is no need for any direct management of funds, and the stake's formula for this Delegator type is:

$$\text{stake} = \min(\text{activeStake}, \text{maxNetworkLimit})$$