From c53218444af2af241b3bc1d8472aba091fbbf2f4 Mon Sep 17 00:00:00 2001 From: Pablo Carranza Velez Date: Tue, 20 Feb 2024 10:57:24 -0300 Subject: [PATCH] chore: add first draft IHorizonStaking --- .../contracts/staking/IHorizonStaking.sol | 157 ++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 packages/contracts/contracts/staking/IHorizonStaking.sol diff --git a/packages/contracts/contracts/staking/IHorizonStaking.sol b/packages/contracts/contracts/staking/IHorizonStaking.sol new file mode 100644 index 000000000..92ebe7a33 --- /dev/null +++ b/packages/contracts/contracts/staking/IHorizonStaking.sol @@ -0,0 +1,157 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +pragma solidity 0.7.6; +pragma abicoder v2; + +interface IHorizonStaking { + struct Provision { + // Service provider that created the provision + address serviceProvider; + // tokens in the provision + uint256 tokens; + // tokens that are being thawed (and will stop being slashable soon) + uint256 tokensThawing; + // timestamp of provision creation + uint64 createdAt; + // authority to slash the provision + address verifier; + // max amount that can be taken by the verifier when slashing, expressed in parts-per-million of the amount slashed + uint32 maxVerifierCut; + // time, in seconds, tokens must thaw before being withdrawn + uint64 thawingPeriod; + } + + // the new "Indexer" struct + struct ServiceProviderInternal { + // Tokens on the Service Provider stake (staked by the provider) + uint256 tokensStaked; + // Tokens used in allocations + uint256 __DEPRECATED_tokensAllocated; + // Tokens locked for withdrawal subject to thawing period + uint256 __DEPRECATED_tokensLocked; + // Block when locked tokens can be withdrawn + uint256 __DEPRECATED_tokensLockedUntil; + // tokens used in a provision + uint256 tokensProvisioned; + // tokens that initiated a thawing in any one of the provider's provisions + uint256 tokensRequestedThaw; + // tokens that have been removed from any one of the provider's provisions after thawing + uint256 tokensFulfilledThaw; + // provisions that take priority for undelegation force thawing + bytes32[] forceThawProvisions; + } + + struct ServiceProvider { + // Tokens on the provider stake (staked by the provider) + uint256 tokensStaked; + // tokens used in a provision + uint256 tokensProvisioned; + // tokens that initiated a thawing in any one of the provider's provisions + uint256 tokensRequestedThaw; + // tokens that have been removed from any one of the provider's provisions after thawing + uint256 tokensFulfilledThaw; + // provisions that take priority for undelegation force thawing + bytes32[] forceThawProvisions; + } + + struct DelegationPool { + uint32 __DEPRECATED_cooldownBlocks; // solhint-disable-line var-name-mixedcase + uint32 __DEPRECATED_indexingRewardCut; // in PPM + uint32 __DEPRECATED_queryFeeCut; // in PPM + uint256 __DEPRECATED_updatedAtBlock; // Block when the pool was last updated + uint256 tokens; // Total tokens as pool reserves + uint256 shares; // Total shares minted in the pool + mapping(address => Delegation) delegators; // Mapping of delegator => Delegation + } + + struct Delegation { + // shares owned by the delegator in the pool + uint256 shares; + // tokens delegated to the pool + uint256 tokens; + // Timestamp when locked tokens can be undelegated (after the timelock) + uint256 tokensLockedUntil; + } + + struct ThawRequest { + // tokens that are being thawed by this request + uint256 tokens; + // the provision id to which this request corresponds to + bytes32 provisionId; + // the address that initiated the thaw request, allowed to remove the funds once thawed + address owner; + // the timestamp when the thawed funds can be removed from the provision + uint64 thawingUntil; + // the value of `ServiceProvider.tokensRequestedThaw` the moment the thaw request is created + uint256 tokensRequestedThawSnapshot; + } + + // whitelist/deny a verifier + function allowVerifier(address verifier, bool allow) external; + + // deposit stake + function stake(uint256 tokens) external; + + // create a provision + function provision( + uint256 tokens, + address verifier, + uint256 maxVerifierCut, + uint256 thawingPeriod + ) external; + + // initiate a thawing to remove tokens from a provision + function thaw(bytes32 provisionId, uint256 tokens) external returns (bytes32); + + // moves thawed stake from a provision back into the provider's available stake + function deprovision(bytes32 thawRequestId) external; + + // moves thawed stake from one provision into another provision + function reprovision(bytes32 thawRequestId, bytes32 provisionId) external; + + // moves thawed stake back to the owner's account - stake is removed from the protocol + function withdraw(bytes32 thawRequestId) external; + + // delegate tokens to a provider + function delegate(address serviceProvider, uint256 tokens) external; + + // undelegate tokens + function undelegate( + address serviceProvider, + uint256 tokens, + bytes32[] provisions + ) external returns (bytes32[]); + + // slash a service provider + function slash( + bytes32 provisionId, + uint256 tokens, + uint256 verifierAmount + ) external; + + // set the Service Provider's preferred provisions to be force thawed + function setForceThawProvisions(bytes32[] provisions); + + // total staked tokens to the provider + // `ServiceProvider.tokensStaked + DelegationPool.serviceProvider.tokens` + function getStake(address serviceProvider) public view returns (uint256 tokens); + + // staked tokens that are currently not provisioned, aka idle stake + // `getStake(serviceProvider) - ServiceProvider.tokensProvisioned` + function getIdleStake(address serviceProvider) public view returns (uint256 tokens); + + // staked tokens the provider can provision before hitting the delegation cap + // `ServiceProvider.tokensStaked * Staking.delegationRatio - Provision.tokensProvisioned` + function getCapacity(address serviceProvider) public view returns (uint256); + + // provisioned tokens that are not being used + // `Provision.tokens - Provision.tokensThawing` + function getTokensAvailable(bytes32 provision) public view returns (uint256 tokens); + + function getServiceProvider(address serviceProvider) + public + view + returns (ServiceProvider memory); + + function getProvision(bytes32 provision) public view returns (Provision memory); +}