Frax Convex Strategy with locked Frax Staked Convex LP tokens

README.md

@@ -7,8 +7,7 @@ For more details about the product, checkout [our docs](https://docs.oeth.com).
 | Branch    | CI/CD Status                                                                                                                                                                                                      |
 | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `master`  | [![Origin DeFi](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml/badge.svg)](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml)                                       |
-| `staging` | [![Origin DeFi](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml/badge.svg?branch=staging)](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml?query=branch%3Astaging) |
-| `stable`  | [![Origin DeFi](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml/badge.svg?branch=stable)](https://github.com/OriginProtocol/origin-dollar/actions/workflows/defi.yml?query=branch%3Astable)   |
+
 
 ## Requirements
 
@@ -32,7 +31,7 @@ cd origin-dollar
 
 ## Description
 
-The `origin-dollar` project is a mono repo that hosts both the `smart contracts` and `dapp` code bases. In order to run this project locally, you will need to run both the `Eth node` and the `dapp` in separate processes or terminals.
+The `origin-dollar` project is a repo that hosts the smart contracts of some Origin DeFi projects including OUSD and OETH. For Governance related contracts, head over to (origin-dollar-governance)[https://github.com/OriginProtocol/ousd-governance]. In order to run this project locally, you will need to run the `Eth node`.
 
 ### Eth Node
 
@@ -41,11 +40,6 @@ The `smart contracts` and all of their associated code are located in the `<proj
 A variety of Hardhat [tasks](https://hardhat.org/guides/create-task.html) are available to interact with the contracts. Additional information can be found by running `npx hardhat` from the `contracts/` directory.
 <br/><br/>
 
-### dapp (Decentralized Application)
-
-The code for `dapp` is located under the `/dapp` directory.
-<br/><br/>
-
 ---
 
 ## Running the node
@@ -78,85 +72,6 @@ This is an option, but a simpler way is to use the `ACCOUNTS_TO_FUND` setting de
 npx hardhat fund --amount 1000 --network localhost
 ```
 
-##### Requirements
-
-- You will need your web3 wallet configured before you can interact with the dapp. Make sure that you have one - refer to [this section](#configure-web3-wallet) for `Metamask` instructions.
-- You will also need the dapp to be running. Refer to [this section](#running-the-dapp-locally) for instructions.
-
-### Configure Web3 Wallet
-
-You will need a web3 wallet to interact with the dapp and sign transactions. Below are the instructions to setup `Metamask` to interact with the dapp running locally.
-
-- Install `Metamask` Chrome extension [HERE](https://metamask.io/)
-- Create/Open `Metamask` wallet
-- Add a custom RPC endpoint
-  - Name: `origin` - just an example
-  - URL: `http://localhost:8545`
-  - Chain ID: `1337`
-    <br/><br/>
-
-#### Add Accounts to Metamask
-
-##### Forked mode
-
-Just use the account(s) you normally use on mainnet.
-
-##### Standalone mode
-
-You can get all the accounts for the locally running node and their associated private keys by running the command
-
-```bash
-# For Standalone mode
-npx hardhat accounts --network localhost
-```
-
-Choose a test account past index 3 (accounts 0-3 are reserved).
-Copy the private key and import it into Metamask as follows:
-
-- Click the current account icon in the upper right corner of `Metamask`
-- Select `Import Account` => paste private key => Click `Import`
-
-Make sure that you select your newly created RPC endpoint in the networks dropdown and use your newly imported account in `Metamask`. You should now be setup to use `Metamask` to interact with the dApp.
-
-Note:
-If you want to add all the accounts via a new `Metamask` wallet and import the `mnemonic` it is located in `contracts/hardhat.config.js`. Make sure that you use Account 4 and up for test accounts as 0-3 are reserved.
-<br/><br/>
-
-### Running the dapp
-
-Open a separate terminal to run the dapp in.
-
-```bash
-# Enter the smart dapp dir (or oeth-dapp)
-cd dapp
-
-# Install the dependencies
-yarn install
-
-# Start the dapp
-yarn run start
-```
-
-- Open http://localhost:3000 in your browser and connect your `Metamask` account. See [this section](#configure-web3-wallet) for instructions if you have not done that yet.
-- Open http://localhost:3000/swap and verify that you have stablecoins in your account. See [this section](#minting-stablecoins-via-hardhat-task) for instructions if you don't see a balance.
-
-If you see a `Runtime Error: underlying network changed`, then rename `dapp/dev.env` to `.env` and restart `yarn`
-
-If you see an error resembling `digital envelope routines::unsupported`, you are likely using an incompatible Node.js version. At last check, v16.20.2 is good.
-
-### Troubleshooting
-
-When freshly starting a node it is usually necessary to also reset Metamask Account being used:
-
-- `Metamask` => `Settings` => `Advanced` => `Reset Account`
-  <br/><br/>
-  This will reset the nonce number that is incorrect if you have submitted any transactions in previous runs of the ethereum node. (Wallet has a too high nonce number comparing to the nonce state on the node)
-
-If you get an `error Command "husky-run" not found.` type of error:
-Go to root of the project and run `npx husky install`
-
----
-
 ## Running Smoke Tests
 
 Smoke tests can be run in 2 modes:

contracts/contracts/interfaces/IFraxConvexLocking.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IFraxConvexLocking {
+    /* ========== EVENTS ========== */
+    event LockedAdditional(
+        address indexed user,
+        bytes32 kek_id,
+        uint256 amount
+    );
+    event LockedLonger(
+        address indexed user,
+        bytes32 kek_id,
+        uint256 new_secs,
+        uint256 new_start_ts,
+        uint256 new_end_ts
+    );
+    event StakeLocked(
+        address indexed user,
+        uint256 amount,
+        uint256 secs,
+        bytes32 kek_id,
+        address source_address
+    );
+    event WithdrawLocked(
+        address indexed user,
+        uint256 liquidity,
+        bytes32 kek_id,
+        address destination_address
+    );
+
+    // Struct for the stake
+    struct LockedStake {
+        bytes32 kek_id;
+        uint256 start_timestamp;
+        uint256 liquidity;
+        uint256 ending_timestamp;
+        uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
+    }
+
+    function curvePool() external view returns (address);
+
+    function curveToken() external view returns (address);
+
+    function earned(address account)
+        external
+        view
+        returns (uint256[] memory new_earned);
+
+    function getAllRewardTokens() external view returns (address[] memory);
+
+    function getReward(address destination_address)
+        external
+        returns (uint256[] memory);
+
+    function getReward2(address destination_address, bool claim_extra_too)
+        external
+        returns (uint256[] memory);
+
+    function getRewardForDuration()
+        external
+        view
+        returns (uint256[] memory rewards_per_duration_arr);
+
+    function lastRewardClaimTime(address) external view returns (uint256);
+
+    function lastUpdateTime() external view returns (uint256);
+
+    function lockAdditional(bytes32 kek_id, uint256 addl_liq) external;
+
+    function lockLonger(bytes32 kek_id, uint256 new_ending_ts) external;
+
+    function lockMultiplier(uint256 secs) external view returns (uint256);
+
+    function lockedLiquidityOf(address account) external view returns (uint256);
+
+    function lockedStakes(address, uint256)
+        external
+        view
+        returns (
+            bytes32 kek_id,
+            uint256 start_timestamp,
+            uint256 liquidity,
+            uint256 ending_timestamp,
+            uint256 lock_multiplier
+        );
+
+    function lockedStakesOf(address account)
+        external
+        view
+        returns (LockedStake[] memory);
+
+    function lockedStakesOfLength(address account)
+        external
+        view
+        returns (uint256);
+
+    function stakeLocked(uint256 liquidity, uint256 secs)
+        external
+        returns (bytes32);
+
+    function withdrawLocked(
+        bytes32 kek_id,
+        address destination_address,
+        bool claim_rewards
+    ) external returns (uint256);
+}

contracts/contracts/interfaces/IFraxConvexStaking.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IFraxConvexStaking is IERC20 {
+    event Deposited(
+        address indexed _user,
+        address indexed _account,
+        uint256 _amount,
+        bool _wrapped
+    );
+    event Withdrawn(address indexed _user, uint256 _amount, bool _unwrapped);
+    event RewardInvalidated(address _rewardToken);
+    event RewardRedirected(address indexed _account, address _forward);
+    event RewardAdded(address _token);
+    event Shutdown();
+
+    struct EarnedData {
+        address token;
+        uint256 amount;
+    }
+
+    function collateralVault() external view returns (address);
+
+    function convexBooster() external view returns (address);
+
+    function convexPool() external view returns (address);
+
+    function convexPoolId() external view returns (uint256);
+
+    function convexToken() external view returns (address);
+
+    function curveToken() external view returns (address);
+
+    function deposit(uint256 _amount, address _to) external;
+
+    function earned(address _account)
+        external
+        returns (EarnedData[] memory claimable);
+
+    function getReward(address _account, address _forwardTo) external;
+
+    function getReward(address _account) external;
+
+    function isShutdown() external view returns (bool);
+
+    function rewardLength() external view returns (uint256);
+
+    function rewardRedirect(address) external view returns (address);
+
+    function rewards(uint256)
+        external
+        view
+        returns (
+            address reward_token,
+            address reward_pool,
+            uint256 reward_integral,
+            uint256 reward_remaining
+        );
+
+    function stake(uint256 _amount, address _to) external;
+
+    function totalBalanceOf(address _account) external view returns (uint256);
+
+    function withdraw(uint256 _amount) external;
+
+    function withdrawAndUnwrap(uint256 _amount) external;
+}

contracts/contracts/mocks/MockOracleRouterNoStale.sol

@@ -25,7 +25,9 @@ contract MockOracleRouterNoStale is OracleRouter {
 
 // @notice Oracle Router used to bypass staleness
 contract MockOETHOracleRouterNoStale is OETHOracleRouter {
-    constructor(address auraPriceFeed) OETHOracleRouter(auraPriceFeed) {}
+    constructor(address auraPriceFeed, address fxsPriceFeed)
+        OETHOracleRouter(auraPriceFeed, fxsPriceFeed)
+    {}
 
     function feedMetadata(address asset)
         internal

contracts/contracts/oracle/OETHOracleRouter.sol

@@ -10,9 +10,11 @@ contract OETHOracleRouter is OracleRouterBase {
     using StableMath for uint256;
 
     address public immutable auraPriceFeed;
+    address public immutable fxsPriceFeed;
 
-    constructor(address _auraPriceFeed) {
+    constructor(address _auraPriceFeed, address _fxsPriceFeed) {
         auraPriceFeed = _auraPriceFeed;
+        fxsPriceFeed = _fxsPriceFeed;
     }
 
     /**
@@ -105,6 +107,16 @@ contract OETHOracleRouter is OracleRouterBase {
             // AURA/ETH
             feedAddress = auraPriceFeed;
             maxStaleness = 0;
+        } else if (asset == 0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0) {
+            /* FXS/ETH PriceFeedPar feed contract
+             *
+             * Is combining the following to feeds to achieve target feed:
+             *  - https://data.chain.link/ethereum/mainnet/crypto-usd/fxs-usd
+             *  - https://data.chain.link/ethereum/mainnet/crypto-usd/eth-usd (inverted)
+             */
+            feedAddress = fxsPriceFeed;
+            // eth-usd heartbeat is 1 hour and fxs-usd feed is 1 day
+            maxStaleness = 1 days + STALENESS_BUFFER;
         } else {
             revert("Asset not available");
         }