@pendle/core-v2 0.7.1-beta-2 → 0.8.0-beta

package/build/artifacts/contracts/interfaces/IPMarketAddRemoveCallback.sol/IPMarketAddRemoveCallback.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/8c5efa66c295b2ee67f1556196780904.json"
-}

package/build/artifacts/contracts/interfaces/IPMarketAddRemoveCallback.sol/IPMarketAddRemoveCallback.json

@@ -1,67 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "IPMarketAddRemoveCallback",
-  "sourceName": "contracts/interfaces/IPMarketAddRemoveCallback.sol",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "lpToAccount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scyUsed",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "ptUsed",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "addLiquidityCallback",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "lpOwed",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scyToAccount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "ptToAccount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "removeLiquidityCallback",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/build/artifacts/contracts/libraries/solmate/Bytes32AddressLib.sol/Bytes32AddressLib.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/f5816395d5e1f2525b60137e72433fa7.json"
-}

package/build/artifacts/contracts/libraries/solmate/Bytes32AddressLib.sol/Bytes32AddressLib.json

@@ -1,10 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "Bytes32AddressLib",
-  "sourceName": "contracts/libraries/solmate/Bytes32AddressLib.sol",
-  "abi": [],
-  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bd83a6ed0f6a6cb1411148557218ce05367c955a2b8660f2b004f54ebed2915f64736f6c634300080f0033",
-  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bd83a6ed0f6a6cb1411148557218ce05367c955a2b8660f2b004f54ebed2915f64736f6c634300080f0033",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/contracts/SuperComposableYield/SCY-implementations/PendleBtrflySCY.sol

@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-
-import "../base-implementations/SCYBase.sol";
-import "../../interfaces/IWXBTRFLY.sol";
-import "../../interfaces/IREDACTEDStaking.sol";
-
-contract PendleBtrflyScy is SCYBase {
-    address public immutable BTRFLY;
-    address public immutable xBTRFLY;
-    address public immutable wxBTRFLY;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _wxBTRFLY
-    ) SCYBase(_name, _symbol, _wxBTRFLY) {
-        require(_wxBTRFLY != address(0), "zero address");
-        wxBTRFLY = _wxBTRFLY;
-        BTRFLY = IWXBTRFLY(wxBTRFLY).BTRFLY();
-        xBTRFLY = IWXBTRFLY(wxBTRFLY).xBTRFLY();
-
-        _safeApprove(BTRFLY, wxBTRFLY, type(uint256).max);
-        _safeApprove(xBTRFLY, wxBTRFLY, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {SCYBase-_deposit}
-     *
-     * The underlying yield token is wxBTRFLY. If the base token is not said token, the contract
-     * first wraps from `tokenIn` to wxBRTRFLY. Then the corresponding amount of shares is returned.
-     *
-     * The exchange rate of wxBTRFLY to shares is 1:1
-     */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == wxBTRFLY) {
-            amountSharesOut = amountDeposited;
-        } else if (tokenIn == xBTRFLY) {
-            // wrapFromxBTRFLY returns amountWXBTRFLYout
-            amountSharesOut = IWXBTRFLY(wxBTRFLY).wrapFromxBTRFLY(amountDeposited);
-        } else {
-            // must be BTRFLY
-            // wrapFromBTRFLY returns amountWXBTRFLYout
-            amountSharesOut = IWXBTRFLY(wxBTRFLY).wrapFromBTRFLY(amountDeposited);
-        }
-    }
-
-    /**
-     * @dev See {SCYBase-_redeem}
-     *
-     * The shares are redeemed into the same amount of wxBTRFLY. If `tokenOut` is not wxBTRFLY
-     * the function unwraps said amount of wxBTRFLY into `tokenOut` for redemption.
-     */
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
-        if (tokenOut == wxBTRFLY) {
-            amountTokenOut = amountSharesToRedeem;
-        } else if (tokenOut == xBTRFLY) {
-            amountTokenOut = IWXBTRFLY(wxBTRFLY).unwrapToxBTRFLY(amountSharesToRedeem);
-        } else {
-            // must be BTRFLY
-            amountTokenOut = IWXBTRFLY(wxBTRFLY).unwrapToBTRFLY(amountSharesToRedeem);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice Calculates and updates the exchange rate of shares to underlying asset token
-     * @dev It is the conversion rate of wxBTRFLY to BTRFLY
-     */
-    function exchangeRate() public view virtual override returns (uint256) {
-        return IWXBTRFLY(wxBTRFLY).xBTRFLYValue(Math.ONE);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @dev See {ISuperComposableYield-getBaseTokens}
-     */
-    function getBaseTokens() public view virtual override returns (address[] memory res) {
-        res = new address[](3);
-        res[0] = BTRFLY;
-        res[1] = xBTRFLY;
-        res[2] = wxBTRFLY;
-    }
-
-    /**
-     * @dev See {ISuperComposableYield-isValidBaseToken}
-     */
-    function isValidBaseToken(address token) public view virtual override returns (bool) {
-        return token == BTRFLY || token == xBTRFLY || token == wxBTRFLY;
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.TOKEN, BTRFLY, IERC20Metadata(BTRFLY).decimals());
-    }
-}

package/contracts/SuperComposableYield/SCY-implementations/PendleJoeLpSCY.sol

@@ -1,245 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-
-import "../../interfaces/IJoePair.sol";
-import "../../interfaces/IJoeRouter02.sol";
-import "../base-implementations/SCYBase.sol";
-import "../../libraries/math/LogExpMath.sol";
-
-contract PendleJoeLpSCY is SCYBase {
-    using Math for uint256;
-
-    address public immutable joeRouter;
-    address public immutable joePair;
-    address public immutable token0;
-    address public immutable token1;
-
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _joeRouter,
-        address _joePair
-    ) SCYBase(_name, _symbol, _joePair) {
-        require(_joeRouter != address(0), "zero address");
-        joeRouter = _joeRouter;
-        joePair = _joePair;
-        token0 = IJoePair(joePair).token0();
-        token1 = IJoePair(joePair).token1();
-        _safeApprove(token0, joeRouter, type(uint256).max);
-        _safeApprove(token1, joeRouter, type(uint256).max);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    DEPOSIT/REDEEM USING BASE TOKENS
-    //////////////////////////////////////////////////////////////*/
-
-    function _deposit(address tokenIn, uint256 amount)
-        internal
-        override
-        returns (uint256 amountSharesOut)
-    {
-        if (tokenIn == joePair) {
-            amountSharesOut = amount;
-        } else {
-            amountSharesOut = _performZapIn(tokenIn, amount);
-        }
-    }
-
-    function _redeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        override
-        returns (uint256 amountBaseOut)
-    {
-        if (tokenOut == joePair) {
-            amountBaseOut = amountSharesToRedeem;
-        } else {
-            amountBaseOut = _performZapOut(tokenOut, amountSharesToRedeem);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                               EXCHANGE-RATE
-    //////////////////////////////////////////////////////////////*/
-
-    function exchangeRate() public view override returns (uint256) {
-        (uint256 reserve0, uint256 reserve1, ) = IJoePair(joePair).getReserves();
-
-        // K = sqrt(reserve0 * reserve1) = pow(reserve0*reserve1, 0.5)
-        uint256 currentK = LogExpMath.pow(reserve0 * reserve1, uint256(LogExpMath.ONE_18 / 2));
-        uint256 totalSupply = IJoePair(joePair).totalSupply();
-        return currentK.divDown(totalSupply);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                MISC FUNCTIONS FOR METADATA
-    //////////////////////////////////////////////////////////////*/
-
-    function getBaseTokens() public view override returns (address[] memory res) {
-        res = new address[](3);
-        res[0] = token0;
-        res[1] = token1;
-        res[2] = joePair;
-    }
-
-    function isValidBaseToken(address token) public view override returns (bool res) {
-        res = (token == token0 || token == token1 || token == joePair);
-    }
-
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
-        return (AssetType.LIQUIDITY, joePair, IERC20Metadata(joePair).decimals());
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    ZAPPING IN/OUT USING ZAPPER'S ALGORITHMS
-    //////////////////////////////////////////////////////////////*/
-
-    function _performZapIn(address fromToken, uint256 amount) internal returns (uint256) {
-        require(fromToken == token0 || fromToken == token1, "Invalid fromToken");
-        // divide intermediate into appropriate amount to add liquidity
-        (uint256 token0Bought, uint256 token1Bought) = _swapIntermediate(fromToken, amount);
-
-        return _joeAddLiquidity(token0Bought, token1Bought, true);
-    }
-
-    function _performZapOut(address toToken, uint256 lpToRemove) internal returns (uint256) {
-        (uint256 token0Received, uint256 token1Received) = _joeRemoveLiquidity(lpToRemove);
-
-        if (toToken == token0) {
-            uint256 token0FromSwap = _token2Token(token1, token0, token1Received);
-            return token0Received + token0FromSwap;
-        } else {
-            uint256 token1FromSwap = _token2Token(token0, token1, token0Received);
-            return token1Received + token1FromSwap;
-        }
-    }
-
-    function _swapIntermediate(address fromToken, uint256 amount)
-        internal
-        returns (uint256 token0Bought, uint256 token1Bought)
-    {
-        (uint256 res0, uint256 res1, ) = IJoePair(joePair).getReserves();
-        if (fromToken == token0) {
-            uint256 amountToSwap = calculateSwapInAmount(res0, amount);
-            //if no reserve or a new pair is created
-            if (amountToSwap <= 0) amountToSwap = amount / 2;
-            token1Bought = _token2Token(fromToken, token1, amountToSwap);
-            token0Bought = amount - amountToSwap;
-        } else {
-            uint256 amountToSwap = calculateSwapInAmount(res1, amount);
-            //if no reserve or a new pair is created
-            if (amountToSwap <= 0) amountToSwap = amount / 2;
-            token0Bought = _token2Token(fromToken, token0, amountToSwap);
-            token1Bought = amount - amountToSwap;
-        }
-    }
-
-    function _joeAddLiquidity(
-        uint256 token0Bought,
-        uint256 token1Bought,
-        bool transferResidual
-    ) internal returns (uint256) {
-        (uint256 amountA, uint256 amountB, uint256 LP) = IJoeRouter02(joeRouter).addLiquidity(
-            token0,
-            token1,
-            token0Bought,
-            token1Bought,
-            1,
-            1,
-            address(this),
-            type(uint256).max
-        );
-
-        if (transferResidual) {
-            //Returning Residue in token0, if any.
-            if (token0Bought - amountA > 0) {
-                _transferOut(token0, msg.sender, token0Bought - amountA);
-            }
-
-            //Returning Residue in token1, if any
-            if (token1Bought - amountB > 0) {
-                _transferOut(token1, msg.sender, token1Bought - amountB);
-            }
-        }
-
-        return LP;
-    }
-
-    function _joeRemoveLiquidity(uint256 lpToRemove)
-        internal
-        returns (uint256 token0Received, uint256 token1Received)
-    {
-        (token0Received, token1Received) = IJoeRouter02(joeRouter).removeLiquidity(
-            token0,
-            token1,
-            lpToRemove,
-            1,
-            1,
-            address(this),
-            type(uint256).max
-        );
-    }
-
-    function calculateSwapInAmount(uint256 reserveIn, uint256 userIn)
-        internal
-        pure
-        returns (uint256)
-    {
-        return
-            (_babylonianSqrt(reserveIn * ((userIn * 3988000) + (reserveIn * 3988009))) -
-                (reserveIn * 1997)) / 1994;
-    }
-
-    function _babylonianSqrt(uint256 y) internal pure returns (uint256 z) {
-        if (y > 3) {
-            z = y;
-            uint256 x = y / 2 + 1;
-            while (x < z) {
-                z = x;
-                x = (y / x + x) / 2;
-            }
-        } else if (y != 0) {
-            z = 1;
-        }
-        // else z = 0
-    }
-
-    /**
-    @notice This function is used to swap ERC20 <> ERC20
-    @param fromToken The token address to swap from.
-    @param toToken The token address to swap to.
-    @param tokens2Trade The amount of tokens to swap
-    @return tokenBought The quantity of tokens bought
-    */
-    function _token2Token(
-        address fromToken,
-        address toToken,
-        uint256 tokens2Trade
-    ) internal returns (uint256 tokenBought) {
-        if (fromToken == toToken) {
-            return tokens2Trade;
-        }
-
-        require(joePair != address(0), "No Swap Available");
-        address[] memory path = new address[](2);
-        path[0] = fromToken;
-        path[1] = toToken;
-
-        tokenBought = IJoeRouter02(joeRouter).swapExactTokensForTokens(
-            tokens2Trade,
-            1,
-            path,
-            address(this),
-            type(uint256).max
-        )[path.length - 1];
-
-        require(tokenBought > 0, "Error Swapping Tokens 2");
-    }
-}

package/contracts/interfaces/IPMarketAddRemoveCallback.sol

@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-
-interface IPMarketAddRemoveCallback {
-    function addLiquidityCallback(
-        uint256 lpToAccount,
-        uint256 scyUsed,
-        uint256 ptUsed,
-        bytes calldata data
-    ) external;
-
-    function removeLiquidityCallback(
-        uint256 lpOwed,
-        uint256 scyToAccount,
-        uint256 ptToAccount,
-        bytes calldata data
-    ) external;
-}

package/contracts/libraries/solmate/Bytes32AddressLib.sol

@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity >=0.8.0;
-
-/// @notice Library for converting between addresses and bytes32 values.
-/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/Bytes32AddressLib.sol)
-library Bytes32AddressLib {
-    function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
-        return address(uint160(uint256(bytesValue)));
-    }
-
-    function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
-        return bytes32(bytes20(addressValue));
-    }
-}

package/deployments/43113-markets/benqi-market.json

@@ -1,7 +0,0 @@
-{
-    "SCY": "0xb597dE4e247945A4D0e577ef65a32Bd4E459C3A7",
-    "expiry": 1672099200,
-    "PT": "0x43963e93a024f1131549C657116321a67e3004B8",
-    "YT": "0x8774E8D4A17f6DbDF93da23189df6026DD77aA34",
-    "market": "0x700E66aD6C98d04f7c426060211fd98f12E0F1b6"
-}

package/deployments/80001-markets/benqi-market.json

@@ -1,7 +0,0 @@
-{
-    "SCY": "0x0fE14FEB320a8DFF7b2Ee47E6BBedF309eF4B0C8",
-    "expiry": 1672099200,
-    "PT": "0x10AfeBB063A3c1A4e8A1E9274c4c9EbDDC574f0a",
-    "YT": "0x52a59B51eb72E6c2e0F3FE4C2940123671a60DA5",
-    "market": "0x0c37E7E799c9A41008b3d246B86F944992660dD5"
-}