Jung/staking

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/IKalypsoStaking.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+interface IKalypsoStaking {
+    function isSupportedToken(address _token) external view returns (bool);
+
+    // function getPoolStake(address _operator, address _token) external view returns (uint256);
+
+    function lockStake(uint256 _jobId, address _operator) external; // Staking Manager only
+
+    function unlockStake(uint256 _jobId) external; // Staking Manager only
+
+    struct PoolLockInfo {
+        address token;
+        uint256 amount;
+        address transmitter;
+    }
+
+    // struct NativeStakingLock {
+    //     address token;
+    //     uint256 amount;
+    // }
+}

contracts/interfaces/staking/INativeStaking.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IKalypsoStaking} from "../staking/IKalypsoStaking.sol";
+
+interface INativeStaking is IKalypsoStaking {
+
+    // TODO: check if timestamp is needed
+    event Staked(address indexed account, address indexed operator, address indexed token, uint256 amount, uint256 timestamp);
+    event SelfStaked(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);
+    event SelfStakeWithdrawn(address indexed operator, address indexed token, uint256 amount, uint256 timestamp);
+
+    // function stakeOf(address _operator, address _token) external view returns (uint256);
+
+    // function stakesOf(address _operator) external view returns (address[] memory _tokens, uint256[] memory _amounts);
+
+    // function isSupportedSignature(bytes4 sig) external view returns (bool);
+}

contracts/interfaces/staking/INativeStakingReward.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+interface INativeStakingReward {
+    function update(address account, address _stakeToken, address _operator) external;
+}

contracts/interfaces/staking/IStakingManager.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+interface IStakingManager {
+    function onJobCreation(uint256 jobId, address operator) external;
+
+    function onJobCompletion(uint256 jobId, address token) external;
+
+    function submitProofs(uint256[] memory jobIds, bytes[] calldata proofs) external;
+
+    function submitProof(uint256 jobId, bytes calldata proof) external;
+
+    function setStakingManager(address _stakingManager) external;
+}

contracts/interfaces/staking/ISymbioticStaking.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IKalypsoStaking} from "./IKalypsoStaking.sol";
+
+interface ISymbioticStaking is IKalypsoStaking {
+    // function stakeOf(address _operator, address _token) external view returns (uint256);
+
+    struct SnapshotTxCountInfo {
+        uint256 idxToSubmit; // idx of pratial snapshot tx to submit
+        uint256 numOfTxs; // total number of txs for the snapshot
+    }
+
+    struct VaultSnapshot {
+        address operator;
+        address vault;
+        address token;
+        uint256 stake;
+    }
+
+    struct SlashResultData {
+        uint256 jobId;
+        SlashResult slashResult;
+    }
+
+    struct SlashResult {
+        uint256 slashAmount;
+        address rewardAddress; // address that transmitted slash reqeust to L1 Vault
+    }
+
+    struct ConfirmedTimestamp {
+        uint256 capturedTimestamp;
+        uint256 rewardShare; // TODO
+        address transmitter;
+    }
+
+    // event OperatorSnapshotSubmitted
+
+    // event VaultSnapshotSubmitted
+
+    // event SlashResultSubmitted
+
+    // event SubmissionCompleted
+
+    /// @notice Returns the captureTimestamp of latest completed snapshot submission
+    function lastConfirmedTimestamp() external view returns (uint256);
+}

contracts/staking/l2_contracts/JobManager.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {IStakingManager} from "../../interfaces/staking/IStakingManager.sol";
+
+/* 
+    JobManager contract is responsible for creating and managing jobs.
+    Staking Manager contract is responsible for locking/unlocking tokens and distributing rewards.
+ */
+contract JobManager {
+    uint256 constant JOB_DURATION = 1 days;
+
+    IStakingManager stakingManager;
+
+    struct JobInfo {
+        address operator;
+        address lockToken;
+        uint256 lockedAmount; // this will go to slasher if the proof is not submitted before deadline
+        uint256 deadline;
+        address dataTransmitter; //
+    }
+
+    mapping(uint256 => JobInfo) public jobs;
+
+    // TODO: check paramter for job details
+    function createJob(uint256 jobId, address operator) external {
+        // TODO: called only from Kalypso Protocol
+
+        // TODO: create a job and record StakeData Transmitter who submitted capture timestamp
+
+
+        // TODO: call creation function in StakingManager
+        stakingManager.onJobCreation(jobId, operator); // lock stake
+    }
+
+    /**
+     * @notice Submit Single Proof
+     */
+    function submitProof(uint256 jobId, bytes calldata proof) public {
+        _verifyProof(jobId, proof);
+    }
+
+    /**
+     * @notice Submit Multiple proofs in single transaction
+     */
+    function submitProofs(uint256[] calldata jobIds, bytes[] calldata proofs) external {
+        require(jobIds.length == proofs.length, "Invalid Length");
+
+        // TODO: close job and distribute rewards
+
+        uint256 len = jobIds.length;
+        for (uint256 idx = 0; idx < len; idx++) {
+            _verifyProof(jobIds[idx], proofs[idx]);
+
+            uint256 jobId;
+            stakingManager.onJobCompletion(jobId, jobs[jobId].lockToken); // unlock stake
+        }
+
+    }
+
+    function _verifyProof(uint256 jobId, bytes calldata proof) internal {
+        // TODO: verify proof
+    }
+
+    function setStakingManager(address _stakingManager) external {
+        stakingManager = IStakingManager(_stakingManager);
+    }
+}