@pendle/core-v2 5.0.1 → 5.0.3

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -17,8 +17,9 @@ contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg, IPGa
         address _pendle,
         address _marketFactory,
         address _marketFactory2,
-        address _marketFactory3
-    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3) {
+        address _marketFactory3,
+        address _marketFactory4
+    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4) {
         votingController = _votingController;
         _disableInitializers();
     }

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -12,9 +12,10 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         address _marketFactory,
         address _marketFactory2,
         address _marketFactory3,
+        address _marketFactory4,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
     {
         _disableInitializers();

package/contracts/core/RewardManager/RewardManager.sol

@@ -39,12 +39,15 @@ abstract contract RewardManager is RewardManagerAbstract {
 
                 RewardState memory _state = rewardState[token];
                 (uint256 lastBalance, uint256 index) = (_state.lastBalance, _state.index);
+
+                uint256 accrued = _selfBalance(tokens[i]) - lastBalance;
+
                 if (index == 0) index = INITIAL_REWARD_INDEX;
+                if (totalShares != 0) index += accrued.divDown(totalShares);
 
-                (uint256 consumedIndex, uint256 consumedReward) = _getConsumedReward(token, lastBalance, totalShares);
                 rewardState[token] = RewardState({
-                    index: (index + consumedIndex).Uint128(),
-                    lastBalance: (lastBalance + consumedReward).Uint128()
+                    index: index.Uint128(),
+                    lastBalance: (lastBalance + accrued).Uint128()
                 });
                 indexes[i] = index;
             }
@@ -55,20 +58,6 @@ abstract contract RewardManager is RewardManagerAbstract {
         }
     }
 
-    function _getConsumedReward(
-        address token,
-        uint256 lastBalance,
-        uint256 totalShares
-    ) private view returns (uint256 consumedIndex, uint256 consumedReward) {
-        if (totalShares == 0) {
-            return (0, 0);
-        }
-
-        uint256 accrued = _selfBalance(token) - lastBalance;
-        consumedIndex = accrued.divDown(totalShares);
-        consumedReward = (consumedIndex * totalShares + PMath.ONE - 1) / PMath.ONE;
-    }
-
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
     function _doTransferOutRewards(

package/contracts/core/StandardizedYield/implementations/Gains/PendleGTokenSY.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../PendleERC4626SY.sol";
+import "../../../../interfaces/IERC4626.sol";
+
+contract PendleGTokenSY is PendleERC4626SY {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _erc4626
+    ) PendleERC4626SY(_name, _symbol, _erc4626) {}
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(yieldToken).convertToAssets(1e18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Gains/PendleGUSDCSY.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleGTokenSY.sol";
+
+contract PendleGUSDCSY is PendleGTokenSY {
+    address public constant gUSDC = 0xd3443ee1e91aF28e5FB858Fbd0D72A63bA8046E0;
+
+    constructor() PendleGTokenSY("SY gUSDC", "SY-gUSDC", gUSDC) {}
+}

package/contracts/core/StandardizedYield/implementations/{PendleGdaiSY.sol → Gains/PendleGdaiSY.sol}

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../SYBase.sol";
-import "../../../interfaces/IERC4626.sol";
+import "../../SYBase.sol";
+import "../../../../interfaces/IERC4626.sol";
 
 contract PendleGDaiSY is SYBase {
     address public immutable DAI;

package/contracts/core/StandardizedYield/implementations/Mantle/PendleMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant METH = 0xcDA86A272531e8640cD7F1a92c01839911B90bb0;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY mETH", "SY-mETH", METH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleERC4626SY.sol

@@ -79,7 +79,12 @@ contract PendleERC4626SY is SYBase {
         return token == yieldToken || token == asset;
     }
 
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonFarmingSY.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+
+contract PendleSophonFarmingSY is SYBaseWithRewards {
+    using Address for address;
+
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable pointManager;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _sophonFarming,
+        uint256 _pid,
+        address _pointManager
+    ) SYBaseWithRewards(_name, _symbol, __getPoolDepositToken(_sophonFarming, _pid)) {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        pointManager = _pointManager;
+        _safeApproveInf(yieldToken, _sophonFarming);
+    }
+
+    function __getPoolDepositToken(address _sophonFarming, uint256 _pid) internal view returns (address) {
+        (address lp, , , , , , , , , ) = ISophonFarming(_sophonFarming).poolInfo(_pid);
+        return lp;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address /*tokenIn*/, uint256 amountDeposited) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).deposit(pid, amountDeposited, 0);
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        ISophonFarming(sophonFarming).withdraw(pid, amountSharesToRedeem);
+        _transferOut(yieldToken, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return ArrayLib.create(pointManager);
+    }
+
+    function _redeemExternalReward() internal override {
+        uint256 owningPoints = _getOwningPoints();
+        if (owningPoints == 0) return;
+        ISophonFarming(sophonFarming).transferPoints(pid, address(this), pointManager, owningPoints);
+        IPSophonPointManager(pointManager).claimPointReceiptToken();
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Sophon/PendleSophonPointManager.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../../erc20/PendleERC20.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import "../../../../interfaces/Sophon/ISophonFarming.sol";
+import "../../../../interfaces/Sophon/IPSophonPointManager.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+
+contract PendleSophonPointManager is PendleERC20, BoringOwnableUpgradeable, IPSophonPointManager {
+    // solhint-disable immutable-vars-naming
+    address public immutable sophonFarming;
+    uint256 public immutable pid;
+    address public immutable sy;
+
+    mapping(address => bool) public isAddressWhitelisted;
+
+    constructor(
+        address _sophonFarming,
+        uint256 _pid,
+        address _sy
+    ) PendleERC20("Sophon Point Receipt Token", __getSpointSymbol(_pid), 18) initializer {
+        sophonFarming = _sophonFarming;
+        pid = _pid;
+        sy = _sy;
+        __BoringOwnable_init();
+    }
+
+    function __getSpointSymbol(uint256 _pid) internal pure returns (string memory) {
+        string memory id = Strings.toString(_pid);
+        return string(abi.encodePacked("SPOINT-", id));
+    }
+
+    function claimPointReceiptToken() external {
+        uint256 floatingPoints = _getOwningPoints() - totalSupply();
+        _mint(sy, floatingPoints);
+    }
+
+    function addWhitelistedAddress(address addr) external onlyOwner {
+        isAddressWhitelisted[addr] = true;
+    }
+
+    function _getOwningPoints() internal view returns (uint256) {
+        return ISophonFarming(sophonFarming).pendingPoints(pid, address(this));
+    }
+
+    function _afterTokenTransfer(address, address to, uint256 amount) internal virtual override {
+        if (amount != 0 && to != address(0) && _shouldBurnReceiptToken(to)) {
+            _burn(to, amount);
+            ISophonFarming(sophonFarming).transferPoints(pid, address(this), to, amount);
+        }
+    }
+
+    function _shouldBurnReceiptToken(address addr) internal view returns (bool) {
+        return addr != sy && !isAddressWhitelisted[addr];
+    }
+}

package/contracts/core/libraries/math/PMath.sol

@@ -67,6 +67,14 @@ library PMath {
         return (a + b - 1) / b;
     }
 
+    function slipUp(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE + factor);
+    }
+
+    function slipDown(uint256 a, uint256 factor) internal pure returns (uint256) {
+        return mulDown(a, ONE - factor);
+    }
+
     // @author Uniswap
     function sqrt(uint256 y) internal pure returns (uint256 z) {
         if (y > 3) {

package/contracts/interfaces/IPActionMarketAuxStatic.sol

@@ -1,6 +1,7 @@
 pragma solidity ^0.8.0;
 
 import "./IPMarket.sol";
+import {ApproxParams} from "../router/base/MarketApproxLib.sol";
 
 interface IPActionMarketAuxStatic {
     function calcPriceImpactPY(address market, int256 netPtOut) external view returns (uint256);
@@ -31,7 +32,45 @@ interface IPActionMarketAuxStatic {
 
     function getPtToSyRate(address market) external view returns (uint256);
 
+    function getYtToSyRate(address market) external view returns (uint256);
+
     function getLpToAssetRate(address market) external view returns (uint256);
 
     function getPtToAssetRate(address market) external view returns (uint256);
+
+    function getYtToAssetRate(address market) external view returns (uint256);
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactSyForPtStaticAndGenerateApproxParams(
+        address market,
+        uint256 exactSyIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactTokenForPtStaticAndGenerateApproxParams(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        );
 }

package/contracts/interfaces/Sophon/IPSophonPointManager.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPSophonPointManager {
+    function claimPointReceiptToken() external;
+}

package/contracts/interfaces/Sophon/ISophonFarming.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface ISophonFarming {
+    function pendingPoints(uint256 _pid, address _user) external view returns (uint256);
+
+    function transferPoints(uint256 _pid, address _sender, address _receiver, uint256 _transferAmount) external;
+
+    function poolInfo(
+        uint256 _pid
+    )
+        external
+        view
+        returns (address, address, uint256, uint256, uint256, uint256, uint256, uint256, uint256, string memory);
+
+    function deposit(uint256 _pid, uint256 _amount, uint256 _boostAmount) external;
+
+    function withdraw(uint256 _pid, uint256 _withdrawAmount) external;
+}

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

@@ -111,6 +111,11 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return getPtToAssetRate(market).divDown(SY.exchangeRate());
     }
 
+    function getYtToSyRate(address market) external view returns (uint256) {
+        (IStandardizedYield SY, , ) = _readTokens(market);
+        return getYtToAssetRate(market).divDown(SY.exchangeRate());
+    }
+
     function getLpToAssetRate(address market) public view returns (uint256) {
         MarketState memory state = _readState(market);
         PYIndex pyIndexCurrent = _pyIndex(market);
@@ -135,6 +140,94 @@ contract ActionMarketAuxStatic is IPActionMarketAuxStatic {
         return _getPtToAssetRate(market, state, _pyIndex(market));
     }
 
+    function getYtToAssetRate(address market) public view returns (uint256) {
+        return PMath.ONE - getPtToAssetRate(market);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactSyForPtStaticAndGenerateApproxParams(
+        address market,
+        uint256 exactSyIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        )
+    {
+        (netPtOut, netSyFee, priceImpact, exchangeRateAfter) = IPActionMarketCoreStatic(address(this))
+            .swapExactSyForPtStatic(market, exactSyIn);
+        approxParams = genApproxParamsToSwapExactSyForPt(market, netPtOut, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function swapExactTokenForPtStaticAndGenerateApproxParams(
+        address market,
+        address tokenIn,
+        uint256 amountTokenIn,
+        uint256 slippage
+    )
+        external
+        view
+        returns (
+            uint256 netPtOut,
+            uint256 netSyMinted,
+            uint256 netSyFee,
+            uint256 priceImpact,
+            uint256 exchangeRateAfter,
+            ApproxParams memory approxParams
+        )
+    {
+        (netPtOut, netSyMinted, netSyFee, priceImpact, exchangeRateAfter) = IPActionMarketCoreStatic(address(this))
+            .swapExactTokenForPtStatic(market, tokenIn, amountTokenIn);
+        approxParams = genApproxParamsToSwapExactSyForPt(market, netPtOut, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function genApproxParamsToSwapExactSyForPt(
+        address market,
+        uint256 netPtOut,
+        uint256 slippage
+    ) public view returns (ApproxParams memory) {
+        MarketState memory state = _readState(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(_pyIndex(market), block.timestamp);
+
+        uint256 guessLowerBound = 0;
+        uint256 guessUpperBound = MarketApproxPtOutLib.calcMaxPtOut(comp, state.totalPt);
+        return genApproxParamsPtOut(netPtOut, guessLowerBound, guessUpperBound, slippage);
+    }
+
+    /// @param slippage A fixed-point number with 18 decimal places
+    function genApproxParamsPtOut(
+        uint256 netPtOut,
+        uint256 guessLowerBound,
+        uint256 guessUpperBound,
+        uint256 slippage
+    ) internal pure returns (ApproxParams memory) {
+        uint256 guessOffchain = netPtOut;
+        uint256 MAX_ITERATION = 30;
+
+        uint256 MIN_EPS_CAP = PMath.ONE / 10 ** 5;
+        uint256 eps = PMath.min(slippage / 2, MIN_EPS_CAP);
+
+        uint256 guessMin = PMath.max(guessLowerBound, netPtOut.slipDown(slippage));
+        uint256 guessMax = PMath.min(guessUpperBound, netPtOut.slipUp(5 * slippage));
+
+        return
+            ApproxParams({
+                guessOffchain: guessOffchain,
+                maxIteration: MAX_ITERATION,
+                eps: eps,
+                guessMin: guessMin,
+                guessMax: guessMax
+            });
+    }
+
     function _getPtToAssetRate(
         address market,
         MarketState memory state,

package/deployments/1-markets/ENA-MAINNET-OCT2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY ENA",
+    "SY": "0x1a7096563C94029DfD55E625A19F099726ac4f3F",
+    "YT": "0xb978b4CC7BD1bcC684c3da0F3305c564ed859014",
+    "PT": "0xAfA002De2DADb57B2b04e32aa4F42a69AdEBF2FD",
+    "market": "0x403829bCE022844f66cDB2911D2260526d4eb843",
+    "expiry": 1730332800,
+    "scalarRoot": "5768198181000000000",
+    "initAnchor": "1102274528000000000",
+    "lnFeeRateRoot": "2995508979000000",
+    "deployTxHash": "0x458db49bf4423b7f2728a58333a8fd138bb59963a870b81d1501e481884e21ac",
+    "deployBlockNumber": 20395113,
+    "reversedFee": 0.2999999999199199
+}

package/deployments/1-markets/USD0++-MAINNET-OCT2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY USD0++",
+    "SY": "0x47bCE1BB5D9A9072161EC25009bcD6e8d367b7D3",
+    "YT": "0x4f0B4e6512630480B868e62a8A1D3451B0e9192d",
+    "PT": "0x270d664d2Fc7D962012a787Aec8661CA83DF24EB",
+    "market": "0x00b321D89A8C36B3929f20B7955080baeD706D1B",
+    "expiry": 1730332800,
+    "scalarRoot": "10299471803000000000",
+    "initAnchor": "1053187309000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0xe16e6086bda6fc63a6fafe457faa0d8749da25e9b31eb25ef5757b432427deda",
+    "deployBlockNumber": 20468430,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/42161-markets/GUSDC-ARBITRUM-SEP2024.json

@@ -0,0 +1,15 @@
+{
+    "name": "GUSDC-ARBITRUM-SEP2024",
+    "SY": "0x0a9eD458E6c283D1E84237e3347333Aa08221d09",
+    "YT": "0x03577ffA91EDB93ac3aEE081EfBE6F323da949e1",
+    "PT": "0x2Be6Fab4d1408e7ad6AD91cE7B77FA2A7670782f",
+    "market": "0xa877a0E177b54A37066c1786F91a1DAb68F094AF",
+    "expiry": 1735171200,
+    "lnFeeRateRoot": "999500333000000",
+    "scalarRoot": "23793702873000000000",
+    "initAnchor": "1059760693000000000",
+    "doCacheIndexSameBlock": false,
+    "deployTxHash": "0x1dc134ce1ab711c37388eb1f02d481310a765200d62bc3fbaf560ee684a1fbd5",
+    "deployBlockNumber": 237601819,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/5000-markets/METH-MANTLE-DEC2024.json

@@ -0,0 +1,15 @@
+{
+    "name": "METH-MANTLE-DEC2024",
+    "SY": "0x9Ab557331dDada945eB2eCE19b90Bd7a843F8665",
+    "YT": "0x007D35c67f97f2a898102a66dF346f9e9422f7f0",
+    "PT": "0x1333B49BBdD06544a25647f9127358D9A9486105",
+    "market": "0x99E83709846b6cB82d47a0D78b175E68497EA28B",
+    "expiry": 1735171200,
+    "lnFeeRateRoot": "999500333000000",
+    "scalarRoot": "17109333040000000000",
+    "initAnchor": "1059728064000000000",
+    "doCacheIndexSameBlock": false,
+    "deployTxHash": "0x7bff0037b3fc02ab80924ea1d428950c5a463839d732ef86e377cf8530eed2d5",
+    "deployBlockNumber": 67403685,
+    "reversedFee": 0.09999999999164011
+}