@pendle/core-v2 4.0.6 → 4.2.0

package/contracts/offchain-helpers/router-static/base/ActionMintRedeemStatic.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../interfaces/IPRouterStatic.sol";
+import "./StorageLayout.sol";
+
+contract ActionMintRedeemStatic is StorageLayout, IPActionMintRedeemStatic {
+    using PMath for uint256;
+
+    function mintPyFromSyStatic(address YT, uint256 netSyToMint) public view returns (uint256 netPYOut) {
+        if (IPYieldToken(YT).isExpired()) revert Errors.YCExpired();
+        return netSyToMint.mulDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function redeemPyToSyStatic(address YT, uint256 netPYToRedeem) public view returns (uint256 netSyOut) {
+        return netPYToRedeem.divDown(pyIndexCurrentViewYt(YT));
+    }
+
+    function mintPyFromTokenStatic(
+        address YT,
+        address tokenIn,
+        uint256 netTokenIn
+    ) external view returns (uint256 netPyOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = mintSyFromTokenStatic(SY, tokenIn, netTokenIn);
+        netPyOut = mintPyFromSyStatic(YT, netSyReceived);
+    }
+
+    function redeemPyToTokenStatic(
+        address YT,
+        uint256 netPYToRedeem,
+        address tokenOut
+    ) external view returns (uint256 netTokenOut) {
+        address SY = IPYieldToken(YT).SY();
+        uint256 netSyReceived = redeemPyToSyStatic(YT, netPYToRedeem);
+        netTokenOut = redeemSyToTokenStatic(SY, tokenOut, netSyReceived);
+    }
+
+    function mintSyFromTokenStatic(
+        address SY,
+        address tokenIn,
+        uint256 netTokenIn
+    ) public view returns (uint256 netSyOut) {
+        return IStandardizedYield(SY).previewDeposit(tokenIn, netTokenIn);
+    }
+
+    function redeemSyToTokenStatic(
+        address SY,
+        address tokenOut,
+        uint256 netSyIn
+    ) public view returns (uint256 netTokenOut) {
+        return IStandardizedYield(SY).previewRedeem(tokenOut, netSyIn);
+    }
+
+    function getAmountTokenToMintSy(
+        address SY,
+        address tokenIn,
+        uint256 netSyOut
+    ) external view returns (uint256 netTokenIn) {
+        uint256 pivotAmount;
+
+        if (tokenIn == address(0)) pivotAmount = 1e18;
+        else pivotAmount = 10 ** IStandardizedYield(SY).decimals();
+
+        uint256 low = pivotAmount;
+        {
+            while (true) {
+                uint256 lowSyOut = mintSyFromTokenStatic(SY, tokenIn, low);
+                if (lowSyOut >= netSyOut) low /= 10;
+                else break;
+            }
+        }
+
+        uint256 high = pivotAmount;
+        {
+            while (true) {
+                uint256 highSyOut = mintSyFromTokenStatic(SY, tokenIn, high);
+                if (highSyOut < netSyOut) high *= 10;
+                else break;
+            }
+        }
+
+        while (low <= high) {
+            uint256 mid = (low + high) / 2;
+            uint256 syOut = mintSyFromTokenStatic(SY, tokenIn, mid);
+
+            if (syOut >= netSyOut) {
+                netTokenIn = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        assert(netTokenIn > 0);
+    }
+
+    function pyIndexCurrentViewMarket(address market) public view returns (uint256) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return pyIndexCurrentViewYt(address(YT));
+    }
+
+    function pyIndexCurrentViewYt(address yt) public view returns (uint256) {
+        IPYieldToken YT = IPYieldToken(yt);
+        IStandardizedYield SY = IStandardizedYield(YT.SY());
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexStored = YT.pyIndexStored();
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            return pyIndexStored;
+        } else {
+            return PMath.max(syIndex, pyIndexStored);
+        }
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionStorageStatic.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./StorageLayout.sol";
+import "../../../interfaces/IPActionStorageStatic.sol";
+import "../../../interfaces/IPMiniDiamond.sol";
+
+contract ActionStorageStatic is StorageLayout, IPActionStorageStatic, IPMiniDiamond {
+    function setDefaultApproxParams(ApproxParams memory params) external onlyOwner {
+        defaultApproxParams = params;
+    }
+
+    function getDefaultApproxParams() external view returns (ApproxParams memory) {
+        return defaultApproxParams;
+    }
+
+    function getOwnerAndPendingOwner() external view returns (address _owner, address _pendingOwner) {
+        _owner = owner;
+        _pendingOwner = pendingOwner;
+    }
+
+    function setFacetForSelectors(SelectorsToFacet[] calldata arr) external onlyOwner {
+        for (uint256 i = 0; i < arr.length; ) {
+            SelectorsToFacet memory s = arr[i];
+            for (uint256 j = 0; j < s.selectors.length; ) {
+                selectorToFacet[s.selectors[j]] = s.facet;
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetAddress(bytes4 selector) external view returns (address res) {
+        res = selectorToFacet[selector];
+        require(res != address(0), "selector not found");
+    }
+
+    // Ownable
+    function transferOwnership(address newOwner, bool direct, bool renounce) external onlyOwner {
+        if (direct) {
+            require(newOwner != address(0) || renounce, "Ownable: zero address");
+
+            emit OwnershipTransferred(owner, newOwner);
+            owner = newOwner;
+            pendingOwner = address(0);
+        } else {
+            pendingOwner = newOwner;
+        }
+    }
+
+    function claimOwnership() external {
+        address _pendingOwner = pendingOwner;
+
+        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
+
+        emit OwnershipTransferred(owner, _pendingOwner);
+        owner = _pendingOwner;
+        pendingOwner = address(0);
+    }
+}

package/contracts/offchain-helpers/router-static/base/ActionVePendleStatic.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../core/libraries/MiniHelpers.sol";
+import "../../../interfaces/IPRouterStatic.sol";
+import "../../../interfaces/IPVotingEscrowMainchain.sol";
+import "../../../LiquidityMining/libraries/VeBalanceLib.sol";
+
+contract ActionVePendleStatic is IPActionVePendleStatic {
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 private constant MAX_LOCK_TIME = 104 weeks;
+    uint128 private constant MIN_LOCK_TIME = 1 weeks;
+
+    IPVotingEscrowMainchain private immutable vePENDLE;
+
+    constructor(IPVotingEscrowMainchain _vePENDLE) {
+        vePENDLE = _vePENDLE;
+    }
+
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
+        if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
+        if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
+
+        if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
+        if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
+
+        LockedPosition memory oldPosition;
+
+        {
+            (uint128 amount, uint128 expiry) = vePENDLE.positionData(user);
+            oldPosition = LockedPosition(amount, expiry);
+        }
+
+        if (newExpiry < oldPosition.expiry) revert Errors.VENotAllowedReduceExpiry();
+
+        uint128 newTotalAmountLocked = additionalAmountToLock + oldPosition.amount;
+        if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
+
+        uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        return newBalance.getCurrentValue();
+    }
+}

package/contracts/offchain-helpers/router-static/base/StorageLayout.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../router/base/MarketApproxLib.sol";
+
+abstract contract StorageLayout {
+    address internal owner;
+    address internal pendingOwner;
+
+    mapping(bytes4 => address) internal selectorToFacet;
+
+    ApproxParams internal defaultApproxParams;
+
+    address internal _deprecated_bulkSellerFactory;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Ownable: caller is not the owner");
+        _;
+    }
+}

package/contracts/oracles/PendlePtOracle.sol

@@ -5,6 +5,9 @@ import "./PendlePtOracleLib.sol";
 import "../interfaces/IPPtOracle.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 
+// This is a pre-deployed version of PendlePtOracleLib with additional utility functions.
+// Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure
+// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
 contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
     using PendlePtOracleLib for IPMarket;
 

package/contracts/oracles/PendlePtOracleLib.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.0;
 import "../interfaces/IPMarket.sol";
 import "../core/libraries/math/PMath.sol";
 
+// This library can & should be integrated directly for optimal gas usage.
+// If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can be used.
 library PendlePtOracleLib {
     using PMath for uint256;
     using PMath for int256;

package/contracts/oracles/PendleRedStoneRateOracleAdapter.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../core/libraries/math/PMath.sol";
+import "../interfaces/IPExchangeRateOracle.sol";
+import {AggregatorV3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+contract PendleRedStoneRateOracleAdapter is IPExchangeRateOracle {
+    using PMath for int256;
+
+    address public immutable oracle;
+    uint8 public immutable decimals;
+
+    constructor(address _redStoneOracle, uint8 _decimals) {
+        oracle = _redStoneOracle;
+        decimals = _decimals;
+    }
+
+    function getExchangeRate() external view returns (uint256) {
+        (, int256 answer, , , ) = IChainlinkAggregator(oracle).latestRoundData();
+        return (answer.Uint() * 10 ** decimals) / 10 ** IChainlinkAggregator(oracle).decimals();
+    }
+}

package/contracts/oracles/samples/{PendleLpGlpOracle.sol → BoringLpGlpOracle.sol}

@@ -10,7 +10,7 @@ import "../../core/libraries/math/PMath.sol";
  * @notice The LP/GLP price gotten from the market using the LpOracleLib is multiplied with the USD price of GLP read from
  * GLPManager contract
  */
-contract PendleLpGlpOracle {
+contract BoringLpGlpOracle {
     using PendleLpOracleLib for IPMarket;
 
     uint32 public immutable twapDuration;

package/contracts/{offchain-helpers → oracles/samples}/BoringLpSeller.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "../interfaces/IPMarket.sol";
+import "../../interfaces/IPMarket.sol";
 
 abstract contract BoringLpSeller {
     bytes internal constant EMPTY_BYTES = abi.encode();

package/contracts/{offchain-helpers → oracles/samples}/BoringPtSeller.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "../interfaces/IPMarket.sol";
+import "../../interfaces/IPMarket.sol";
 
 abstract contract BoringPtSeller {
     bytes internal constant EMPTY_BYTES = abi.encode();

package/contracts/oracles/samples/BoringPtUsdChainlinkOracle.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPPtOracle.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../PendleLpOracleLib.sol";
+
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiplied by the default USD price of the asset, as read from Chainlink Oracles.
+ * For more details into how the oracle is implemented, refer to PendlePtOracle & PendlePtOracleLib.
+ */
+contract BoringPtUsdChainlinkOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+    address public immutable ptOracle;
+
+    constructor(uint32 _twapDuration, address _market, address _feed, address _ptOracle) {
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        // required only for sample2
+        ptOracle = _ptOracle;
+    }
+
+    /// @notice direct integration with PendlePtOracleLib, which optimizes gas efficiency.
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample1() external view virtual returns (uint256) {
+        uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ptRate) / PMath.ONE;
+    }
+
+    /// @notice integration with the PendlePtOracle contract, resulting in a smaller bytecode size and simpler structure
+    /// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample2() external view virtual returns (uint256) {
+        uint256 ptRate = IPPtOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ptRate) / PMath.ONE;
+    }
+
+    function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return feedDecimals < 18 ? rawPrice * 10 ** (18 - feedDecimals) : rawPrice / 10 ** (feedDecimals - 18);
+    }
+
+    // ------------------ NOT TO INCLUDE IN PRODUCTION CODE ------------------
+
+    error IncreaseCardinalityRequired(uint16 cardinalityRequired);
+    error AdditionalWaitRequired(uint32 duration);
+
+    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
+    function checkOracleState() external view {
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPtOracle(
+            ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired) {
+            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait for
+            // at least the twapDuration, to allow data population.
+            revert IncreaseCardinalityRequired(cardinalityRequired);
+        }
+
+        if (!oldestObservationSatisfied) {
+            // It's necessary to wait for at least the twapDuration, to allow data population.
+            revert AdditionalWaitRequired(twapDuration);
+        }
+    }
+}

package/deployments/1-markets/EZETH-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY ezETH",
+    "SY": "0x22E12A50e3ca49FB183074235cB1db84Fe4C716D",
+    "YT": "0x256Fb830945141f7927785c06b65dAbc3744213c",
+    "PT": "0xeEE8aED1957ca1545a0508AfB51b53cCA7e3c0d1",
+    "market": "0xDe715330043799D7a80249660d1e6b61eB3713B3",
+    "expiry": 1714003200,
+    "scalarRoot": "11664642502000000000",
+    "initAnchor": "1056877081000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/1-markets/RSETH-KELP-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Kelp DAO rsETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0x0ED3A1D45DfdCf85BCc6C7BAFDC0170A357B974C",
+    "PT": "0xB05cABCd99cf9a73b19805edefC5f67CA5d1895E",
+    "market": "0x4f43c77872Db6BA177c270986CD30c3381AF37Ee",
+    "expiry": 1719446400,
+    "scalarRoot": "11473762817000000000",
+    "initAnchor": "1090881589000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/1-markets/RSWETH-JUNE2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rswETH",
+    "SY": "0x7786729eEe8b9d30fE7d91fDFf23A0f1D0C615D9",
+    "YT": "0x4AfdB1B0f9A56922e398D29239453e6A06148eD0",
+    "PT": "0x5cb12D56F5346a016DBBA8CA90635d82e6D1bcEa",
+    "market": "0x1729981345aa5CaCdc19eA9eeffea90cF1c6e28b",
+    "expiry": 1719446400,
+    "scalarRoot": "10561891189000000000",
+    "initAnchor": "1080503767000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/1-markets/USDE-APR2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY USDe",
+    "SY": "0x248d83f7Ac03CEbCC06d5C1A52c9B5d0EbB9936e",
+    "YT": "0xA99A4329c49369fB41e6CB6852535Bbf3d4f749b",
+    "PT": "0x0869055C098Fe927E1816CAAfb16E9133e5258FE",
+    "market": "0xE02C61247185883f499BD834250093d6bca0DB77",
+    "expiry": 1712188800,
+    "scalarRoot": "12474388716000000000",
+    "initAnchor": "1027315794000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/42161-markets/RSETH-APR2024-ARBITRUM.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY rsETH",
+    "SY": "0xf176fB51F4eB826136a54FDc71C50fCd2202E272",
+    "YT": "0x28DF0f193D8e45073BC1db6F2347812C031bA818",
+    "PT": "0x8D164E0C662C9E199baaC9E97b6A8664c75700EA",
+    "market": "0x6F02C88650837C8dfe89F66723c4743E9cF833cd",
+    "expiry": 1714003200,
+    "scalarRoot": "13486943734000000000",
+    "initAnchor": "1050863540000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/42161-markets/SILO-WSTETH-ETH-DEC2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY sETH-wstEthSilo",
+    "SY": "0xc49d8fdA920a46B21E1821780238f9E7A0de68df",
+    "YT": "0xAE602e0560Fd3aDE52d4E94D1cDbe63E61019693",
+    "PT": "0xD5AabeDA88c31858E5f60905185f8697bE185e55",
+    "market": "0xACcd9A7cb5518326BeD715f90bD32CDf2fEc2D14",
+    "expiry": 1735171200,
+    "scalarRoot": "55387378943000000000",
+    "initAnchor": "1051126109000000000",
+    "lnFeeRateRoot": "499875041000000"
+}

package/deployments/42161-markets/WEETH-APR2024.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY weETH",
+    "SY": "0xa6C895EB332E91c5b3D00B7baeEAae478cc502DA",
+    "YT": "0xF28Db483773E3616DA91FDfa7b5D4090Ac40cC59",
+    "PT": "0x9bEcd6b4Fb076348A455518aea23d3799361FE95",
+    "market": "0xE11f9786B06438456b044B3E21712228ADcAA0D1",
+    "expiry": 1714003200,
+    "scalarRoot": "13422165649000000000",
+    "initAnchor": "1056001760000000000",
+    "lnFeeRateRoot": "999500333000000"
+}

package/deployments/core.ts

@@ -0,0 +1,29 @@
+import ethCoreJSON from './1-core.json';
+
+export interface PendleCore {
+    PENDLE: string;
+    yieldContractFactory: string;
+    marketFactory: string;
+    bulkSellerFactory: string;
+    bulkSellerOffchain: string;
+    router: string;
+    routerStatic: string;
+    vePendle: string;
+    gaugeController: string;
+}
+
+export interface PendleCoreMainchain extends PendleCore {
+    senderEndpoint: string;
+    votingController: string;
+    feeDistributor: string;
+}
+
+export interface PendleCoreSidechain extends PendleCore {
+    receiverEndpoint: string;
+}
+
+const ethCore: PendleCoreMainchain = ethCoreJSON;
+
+export const pendleCore = {
+    ethereum: ethCore,
+};

package/deployments/index.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export * from './markets';
+export * from './misc';
+export * from '../typechain-types';

package/deployments/markets/ape-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketApeJune292022JSON from '../1-markets/APE-JUNE-29.json';
+export const apeJune292022: MarketDeployment = marketApeJune292022JSON;

package/deployments/markets/balancer-reth-dec-28-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerRethDec282023JSON from '../1-markets/BALANCER-LP-AURA-RETH-WETH-28DEC.json';
+export const balancerRethDec282023: MarketDeployment = marketBalancerRethDec282023JSON;

package/deployments/markets/balancer-wsteth-jun-27-2024.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketBalancerWstEthJun272024JSON from '../1-markets/BALANCER-LP-AURA-WSTETH-WETH-JUN272024.json';
+export const balancerWstEthJun272024: MarketDeployment = marketBalancerWstEthJun272024JSON;

package/deployments/markets/curve-fraxusdc-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketCurveFraxUsdcMarch302023JSON from '../1-markets/FRAXUSDC-CURVELP-MARCH30.json';
+export const curveFraxUsdcMarch302023: MarketDeployment = marketCurveFraxUsdcMarch302023JSON;

package/deployments/markets/index.ts

@@ -0,0 +1,17 @@
+import { apeJune292022 } from './ape-june-29-2023';
+import { balancerRethDec282023 } from './balancer-reth-dec-28-2023';
+import { balancerWstEthJun272024 } from './balancer-wsteth-jun-27-2024';
+import { curveFraxUsdcMarch302023 } from './curve-fraxusdc-march-30-2023';
+import { looksMarch302023 } from './looks-march-30-2023';
+import { stEthJune292023 } from './steth-june-29-2023';
+import { stEthMarch302023 } from './steth-march-30-2023';
+
+export const markets = {
+    apeJune292022,
+    balancerRethDec282023,
+    balancerWstEthJun272024,
+    curveFraxUsdcMarch302023,
+    looksMarch302023,
+    stEthJune292023,
+    stEthMarch302023,
+};

package/deployments/markets/looks-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketLooksMarch302023JSON from '../1-markets/LOOKS-STAKING-MARCH30.json';
+export const looksMarch302023: MarketDeployment = marketLooksMarch302023JSON;

package/deployments/markets/steth-june-29-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthJune292023JSON from '../1-markets/STETH-JUNE29.json';
+export const stEthJune292023: MarketDeployment = marketStEthJune292023JSON;

package/deployments/markets/steth-march-30-2023.ts

@@ -0,0 +1,3 @@
+import { MarketDeployment } from './types';
+import marketStEthMarch302023JSON from '../1-markets/STETH-MARCH30.json';
+export const stEthMarch302023: MarketDeployment = marketStEthMarch302023JSON;

package/deployments/markets/types.ts

@@ -0,0 +1,9 @@
+export interface MarketDeployment {
+    name: string;
+    SY: string;
+    YT: string;
+    PT: string;
+    market: string;
+    expiry: number;
+    bulkSeller?: string;
+}