Jung/staking

.gitmodules

@@ -0,0 +1,12 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/openzeppelin-foundry-upgrades"]
+	path = lib/openzeppelin-foundry-upgrades
+	url = https://github.com/OpenZeppelin/openzeppelin-foundry-upgrades
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "lib/openzeppelin-contracts-upgradeable"]
+	path = lib/openzeppelin-contracts-upgradeable
+	url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable

contracts/interfaces/IL2Staking.sol

@@ -3,9 +3,9 @@
 pragma solidity ^0.8.0;
 
 interface IL2Staking {
-    function stake(address generatorAddress, uint256 amount) external returns (uint256);
-
     function intendToReduceStake(uint256 stakeToReduce) external;
 
+    function stake(address generatorAddress, uint256 amount) external returns (uint256);
+
     function unstake(address receiver) external;
 }

contracts/interfaces/staking/IInflationRewardManager.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+interface IInflationRewardManager {
+    function updatePendingInflationReward(address _operator) external returns (uint256 timestampIdx, uint256 pendingInflationReward);
+
+    function updateEpochTimestampIdx() external;
+
+    function transferInflationRewardToken(address _to, uint256 _amount) external;
+}

contracts/interfaces/staking/IJobManager.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+interface IJobManager {
+    function createJob(uint256 _jobId, address _requester, address _operator, uint256 _feeAmount) external;
+
+    function submitProof(uint256 jobId, bytes calldata proof) external;
+
+    function refundFee(uint256 jobId) external;
+
+    function operatorRewardShares(address _operator) external view returns (uint256);    
+}

contracts/interfaces/staking/INativeStaking.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IStakingPool} from "../staking/IStakingPool.sol";
+
+interface INativeStaking is IStakingPool {
+
+    function stake(address stakeToken, address operator, uint256 amount) external;
+
+    // TODO: check if timestamp is needed
+    event Staked(address indexed account, address indexed operator, address indexed token, uint256 amount, uint256 timestamp);
+    event StakeWithdrawn(address indexed account, address indexed operator, address indexed token, uint256 amount, uint256 timestamp);
+}

contracts/interfaces/staking/INativeStakingReward.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {IRewardDistributor} from "./IRewardDistributor.sol";
+
+interface INativeStakingReward is IRewardDistributor {
+    function update(address account, address _stakeToken, address _operator) external;
+}

contracts/interfaces/staking/IRewardDistributor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+interface IRewardDistributor {
+    function updateFeeReward(address _stakeToken, address _operator, uint256 _rewardAmount) external;
+
+    function updateInflationReward(address _operator, uint256 _rewardAmount) external;
+
+    function onStakeUpdate(address _account, address _stakeToken, address _operator) external;
+
+    function onClaimReward(address _account, address _operator) external;
+
+    function onSlash() external;
+
+    function setStakeToken(address _stakingPool, bool _isSupported) external;
+}

contracts/interfaces/staking/IStakingManager.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+import {Struct} from "../../lib/staking/Struct.sol";
+
+pragma solidity ^0.8.26;
+
+interface IStakingManager {
+    function onJobCreation(uint256 jobId, address operator) external;
+
+    function onJobCompletion(uint256 jobId, address operator, uint256 feePaid) external;
+
+    function onSlashResult(Struct.JobSlashed[] calldata slashedJobs) external;
+
+    function distributeInflationReward(address operator, uint256 rewardAmount, uint256 timestampIdx) external;
+
+    function getPoolConfig(address pool) external view returns (Struct.PoolConfig memory);
+}

contracts/interfaces/staking/IStakingPool.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Struct} from "../../lib/staking/Struct.sol";
+
+interface IStakingPool {
+    function isSupportedStakeToken(address stakeToken) external view returns (bool);
+
+    function lockStake(uint256 jobId, address operator) external; // Staking Manager only
+
+    function onJobCompletion(uint256 jobId, address operator, uint256 feeRewardAmount, uint256 inflationRewardAmount, uint256 timestampIdx) external; // Staking Manager only
+
+    function slash(Struct.JobSlashed[] calldata slashedJobs) external; // Staking Manager only  
+
+    function getOperatorStakeAmount(address stakeToken, address operator) external view returns (uint256);
+
+    function getOperatorActiveStakeAmount(address stakeToken, address operator) external view returns (uint256);
+
+    function rewardDistributor() external view returns (address);
+
+    function distributeInflationReward(address operator, uint256 rewardAmount, uint256 timestampIdx) external; // Staking Manager only
+
+    function getStakeTokenList() external view returns (address[] memory);
+
+    function getStakeTokenWeights() external view returns (address[] memory, uint256[] memory);
+
+    function tokenSelectionWeightSum() external view returns (uint256);
+
+    function getStakeAmount(address stakeToken, address staker, address operator) external view returns (uint256);
+}

contracts/interfaces/staking/ISymbioticStaking.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IStakingPool} from "./IStakingPool.sol";
+
+import {Struct} from "../../lib/staking/Struct.sol";    
+
+interface ISymbioticStaking is IStakingPool {
+    function submitVaultSnapshot(
+        uint256 _index,
+        uint256 _numOfTxs, // number of total transactions
+        bytes calldata _vaultSnapshotData,
+        bytes calldata _signature
+    ) external;
+
+    function submitSlashResult(
+        uint256 _index,
+        uint256 _numOfTxs, // number of total transactions
+        bytes memory _slashResultData,
+        bytes memory _signature
+    ) external;
+
+    function getTxCountInfo(uint256 _captureTimestamp, address _transmitter, bytes32 _type) external view returns (Struct.SnapshotTxCountInfo memory);
+
+    function getSubmissionStatus(uint256 _captureTimestamp, address _transmitter) external view returns (bytes32);
+
+
+
+    function confirmedTimestampInfo(uint256 _idx) external view returns (Struct.ConfirmedTimestamp memory);
+
+    // event OperatorSnapshotSubmitted
+
+    // event VaultSnapshotSubmitted
+
+    // event SlashResultSubmitted
+
+    // event SubmissionCompleted
+
+    /// @notice Returns the captureTimestamp of latest completed snapshot submission
+    function latestConfirmedTimestamp() external view returns (uint256);
+
+    /// @notice Returns the timestampIdx of latest completed snapshot submission
+    function latestConfirmedTimestampIdx() external view returns (uint256);
+}

contracts/interfaces/staking/ISymbioticStakingReward.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+import {Struct} from "../../lib/staking/Struct.sol";
+
+pragma solidity ^0.8.26;
+
+interface ISymbioticStakingReward {
+    function claimReward(address _operator) external;
+
+    function updateFeeReward(address _stakeToken, address _operator, uint256 _amount) external;
+
+    function updateInflationReward(address _operator, uint256 _rewardAmount) external;
+
+    function onSnapshotSubmission(Struct.VaultSnapshot[] calldata _vaultSnapshots) external;
+
+    function onSnapshotSubmission(address _vault, address _operator) external;
+}

contracts/lib/staking/Struct.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+library Struct {
+
+    /*=========================== Job Manager =============================*/
+    struct JobInfo {
+        address requester;
+        address operator;
+        uint256 feePaid;
+        uint256 deadline;
+    }
+
+    /*========================= Staking Manager ===========================*/
+
+    struct PoolConfig {
+        uint256 share;
+        bool enabled;
+    }
+
+    /*=========================== Staking Pool ============================*/
+
+    struct PoolLockInfo {
+        address token;
+        uint256 amount;
+        address transmitter;
+    }
+
+    /*========================== Native Staking ===========================*/
+
+    struct NativeStakingLock {
+        address token;
+        uint256 amount;
+    }
+
+    struct JobSlashed {
+        uint256 jobId;
+        address operator; // TODO: check if cheaper than pulling from JobManager
+        address rewardAddress;
+    }
+
+    struct WithdrawalRequest {
+        address stakeToken;
+        uint256 amount;
+        uint256 withdrawalTime;
+    }
+
+    /*========================= Symbiotic Staking =========================*/
+
+    struct VaultSnapshot {
+        address operator;
+        address vault;
+        address stakeToken;
+        uint256 stakeAmount;
+    }
+
+    struct SnapshotTxCountInfo {
+        uint256 idxToSubmit; // idx of pratial snapshot tx to submit
+        uint256 numOfTxs; // total number of txs for the snapshot
+    }
+
+    struct ConfirmedTimestamp {
+        uint256 captureTimestamp;
+        address transmitter;
+        uint256 transmitterComissionRate;
+    }
+
+    struct SymbioticStakingLock {
+        address stakeToken;
+        uint256 amount;
+    }
+}