@pendle/core-v2 6.6.0 → 6.6.1

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.dbg.json

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

package/build/artifacts/contracts/router/math/MarketApproxLibOnchain.sol/MarketApproxPtOutLibOnchain.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibOnchain",
   "sourceName": "contracts/router/math/MarketApproxLibOnchain.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212208726051c453841b4236757faf984375f0a68794d2b64efca988d8877ad6e99d864736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212208726051c453841b4236757faf984375f0a68794d2b64efca988d8877ad6e99d864736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212200d7413abdb872e5b5a8bbc78892d3079ede81e32ae79698279c5a62c3f4aef0964736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212200d7413abdb872e5b5a8bbc78892d3079ede81e32ae79698279c5a62c3f4aef0964736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.dbg.json

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

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtInLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtInLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122097d2455c0135a6136c6989c88854c3228b6dfd6f9c11aae96f6f33f342c185b364736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122097d2455c0135a6136c6989c88854c3228b6dfd6f9c11aae96f6f33f342c185b364736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b15ed4506ea173efdf5a1c91008b9ea868e37437fa7a7eda34843eb85b61d08364736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b15ed4506ea173efdf5a1c91008b9ea868e37437fa7a7eda34843eb85b61d08364736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.dbg.json

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

package/build/artifacts/contracts/router/math/MarketApproxLibV2.sol/MarketApproxPtOutLibV2.json

@@ -3,8 +3,8 @@
   "contractName": "MarketApproxPtOutLibV2",
   "sourceName": "contracts/router/math/MarketApproxLibV2.sol",
   "abi": [],
-  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d1ad5c07c065b18bb2feed5d10d803b42bf8f63a455df8110c7743600af93ceb64736f6c634300081e0033",
-  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d1ad5c07c065b18bb2feed5d10d803b42bf8f63a455df8110c7743600af93ceb64736f6c634300081e0033",
+  "bytecode": "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d61e3865ad4a7726615c39319c8ef235ee1c10bfc13aed9dc4e3b5c04c0464b664736f6c634300081e0033",
+  "deployedBytecode": "0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d61e3865ad4a7726615c39319c8ef235ee1c10bfc13aed9dc4e3b5c04c0464b664736f6c634300081e0033",
   "linkReferences": {},
   "deployedLinkReferences": {}
 }

package/contracts/cross-chain/FixedPricePTAMMV2.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {IPFixedPricePTAMMSwapCallback, IPFixedPricePTAMMV2} from "../interfaces/IPFixedPricePTAMMV2.sol";
+
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {PMath} from "../core/libraries/math/PMath.sol";
+
+contract FixedPricePTAMMV2 is
+    IPFixedPricePTAMMV2,
+    BoringOwnableUpgradeableV2,
+    ERC20Upgradeable,
+    ReentrancyGuardUpgradeable,
+    TokenHelper
+{
+    // cast index-erc7201 "pendle.FixedPricePTAMM.storage"
+    uint256 internal constant STORAGE_SLOT = 0xbbf04d9aae855c6bd76c8f4ba7a918994ad0d002f537323e58c83cbfe5249000;
+
+    using PMath for uint256;
+    using PMath for int256;
+
+    address public immutable outputToken;
+
+    constructor(address _outputToken) {
+        _disableInitializers();
+        outputToken = _outputToken;
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+        __ERC20_init(
+            string.concat(IERC20Metadata(outputToken).name(), " receipt"),
+            string.concat(IERC20Metadata(outputToken).symbol(), "-receipt")
+        );
+        __ReentrancyGuard_init();
+    }
+
+    function decimals() public view override(ERC20Upgradeable, IERC20MetadataUpgradeable) returns (uint8) {
+        return IERC20Metadata(outputToken).decimals();
+    }
+
+    struct OracleData {
+        bool isPaused;
+        address oracle;
+        // @notice This can be seen as the price at maturity.
+        // @notice This can help with decimals conversion.
+        uint256 multiplier;
+    }
+
+    struct Storage {
+        mapping(address PT => OracleData) priceOracle;
+        mapping(address PT => uint256) totalPT;
+        mapping(address user => bool) isWhitelisted;
+    }
+
+    function $() internal pure returns (Storage storage res) {
+        assembly ("memory-safe") {
+            res.slot := STORAGE_SLOT
+        }
+    }
+
+    function priceOracle(address PT)
+        public
+        view
+        returns (bool isPaused, IPChainlinkOracleEssential oracle, uint256 multiplier)
+    {
+        OracleData memory data = $().priceOracle[PT];
+        isPaused = data.isPaused;
+        oracle = IPChainlinkOracleEssential(data.oracle);
+        multiplier = data.multiplier;
+
+        require(address(oracle) != address(0), "FixedPricePTAMMV2: oracle not set");
+    }
+
+    function totalPt(address PT) external view returns (uint256) {
+        return $().totalPT[PT];
+    }
+
+    function isWhitelisted(address user) external view returns (bool) {
+        return $().isWhitelisted[user];
+    }
+
+    function previewSwapExactPtForToken(address PT, uint256 exactPtIn) public view returns (uint256 amountTokenOut) {
+        (bool isPaused, IPChainlinkOracleEssential oracle, uint256 multiplier) = priceOracle(PT);
+        require(!isPaused, "FixedPricePTAMMV2: trading paused");
+
+        (, int256 rawPrice,,,) = oracle.latestRoundData();
+
+        // exactPtIn * rawPrice * multiplier
+        return (exactPtIn * rawPrice.Uint() * multiplier) / (PMath.ONE * PMath.ONE);
+    }
+
+    function swapExactPtForToken(address receiver, address PT, uint256 exactPtIn, bytes calldata data)
+        external
+        nonReentrant
+        returns (uint256 netTokenOut)
+    {
+        netTokenOut = previewSwapExactPtForToken(PT, exactPtIn);
+
+        _transferOut(outputToken, receiver, netTokenOut);
+
+        if (data.length > 0) {
+            IPFixedPricePTAMMSwapCallback(msg.sender).swapCallback(netTokenOut, exactPtIn, data);
+        }
+
+        $().totalPT[PT] += exactPtIn;
+        require(_selfBalance(PT) >= $().totalPT[PT], "FixedPricePTAMMV2: insufficient PT received");
+
+        emit Swap(msg.sender, receiver, PT, exactPtIn, netTokenOut);
+    }
+
+    // Add/remove funds
+
+    modifier onlyWhitelisted() {
+        require($().isWhitelisted[msg.sender], "FixedPricePTAMMV2: Not whitelisted");
+        _;
+    }
+
+    function addFundWhitelisted(uint256 amount) external onlyWhitelisted nonReentrant {
+        _transferIn(outputToken, msg.sender, amount);
+        _mint(msg.sender, amount);
+        emit TokenFunded(msg.sender, amount);
+    }
+
+    function removeFund(uint256 amount) external nonReentrant {
+        _burn(msg.sender, amount);
+        _transferOut(outputToken, msg.sender, amount);
+        emit TokenWithdrawn(msg.sender, amount);
+    }
+
+    // Admin functions
+
+    function withdrawPt(address PT, uint256 amount) external onlyOwner {
+        _transferOut(PT, msg.sender, amount);
+        $().totalPT[PT] -= amount;
+    }
+
+    function setWhitelist(address user, bool isWhitelisted_) external onlyOwner {
+        $().isWhitelisted[user] = isWhitelisted_;
+        emit WhitelistUpdated(user, isWhitelisted_);
+    }
+
+    function setPriceOracle(address PT, address _priceOracle, uint256 _multiplier) external onlyOwner {
+        $().priceOracle[PT].oracle = _priceOracle;
+        $().priceOracle[PT].multiplier = _multiplier;
+        emit PriceOracleUpdated(PT, _priceOracle);
+    }
+
+    function setPausePtTrading(address PT, bool isPaused) external onlyOwner {
+        $().priceOracle[PT].isPaused = isPaused;
+        emit PauseStatusUpdated(PT, isPaused);
+    }
+}

package/contracts/{router/ActionCrossChain.sol → cross-chain/PendleSwapHelper.sol}

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import {IPActionCrossChain, TokenOutput} from "../interfaces/IPActionCrossChain.sol";
-import {IPFixedPricePTAMM} from "../interfaces/IPFixedPricePTAMM.sol";
-import {ActionBase} from "./base/ActionBase.sol";
-import {IPSwapAggregator, SwapType} from "./swap-aggregator/IPSwapAggregator.sol";
+import {TokenHelper} from "../core/libraries/TokenHelper.sol";
+import {IPFixedPricePTAMMV2} from "../interfaces/IPFixedPricePTAMMV2.sol";
+import {IPSwapHelper, TokenOutput} from "../interfaces/IPSwapHelper.sol";
+import {IPSwapAggregator, SwapType} from "../router/swap-aggregator/IPSwapAggregator.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-contract ActionCrossChain is ActionBase, IPActionCrossChain {
+contract PendleSwapHelper is IPSwapHelper, TokenHelper {
     function swapWithFixedPricePTAMM(
         address receiver,
         address fixedPricePTAMM,
@@ -15,9 +15,13 @@ contract ActionCrossChain is ActionBase, IPActionCrossChain {
         uint256 exactPtIn,
         TokenOutput calldata out
     ) external returns (uint256 netTokenOut) {
+        require(
+            out.tokenRedeemSy == IPFixedPricePTAMMV2(fixedPricePTAMM).outputToken(), "SwapHelper: INVALID_TOKEN_REDEEM"
+        );
+
         _transferFrom(IERC20(PT), msg.sender, fixedPricePTAMM, exactPtIn);
-        uint256 tokenOut = IPFixedPricePTAMM(fixedPricePTAMM)
-            .swapExactPtForToken(__swapDestination(receiver, out), PT, exactPtIn, out.tokenRedeemSy, EMPTY_BYTES);
+        uint256 tokenOut = IPFixedPricePTAMMV2(fixedPricePTAMM)
+            .swapExactPtForToken(__swapDestination(receiver, out), PT, exactPtIn, "");
         return __handleTokenOutput(receiver, tokenOut, out);
     }
 

package/contracts/cross-chain/funder/BridgeFunder.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.30;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {BoringOwnableUpgradeableV2} from "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import {TokenHelper} from "../../core/libraries/TokenHelper.sol";
+import {BridgeData, IPBridgeFunder} from "../../interfaces/IPBridgeFunder.sol";
+import {IPDepositBox} from "../../interfaces/IPDepositBox.sol";
+import {IPDepositBoxFactory} from "../../interfaces/IPDepositBoxFactory.sol";
+
+contract BridgeFunder is IPBridgeFunder, BoringOwnableUpgradeableV2, TokenHelper {
+    using Address for address;
+    using SafeERC20 for IERC20;
+
+    IPDepositBoxFactory public immutable DEPOSIT_BOX_FACTORY;
+
+    constructor(address depositBoxFactory_) {
+        _disableInitializers();
+        DEPOSIT_BOX_FACTORY = IPDepositBoxFactory(depositBoxFactory_);
+    }
+
+    function initialize(address _owner) external initializer {
+        __BoringOwnableV2_init(_owner);
+    }
+
+    modifier onlyDepositBox() {
+        IPDepositBox box = IPDepositBox(msg.sender);
+        address owner = box.OWNER();
+        uint32 boxId = box.BOX_ID();
+
+        (address computedBox,,) = DEPOSIT_BOX_FACTORY.computeDepositBox(owner, boxId);
+        require(computedBox == address(box), "BridgeFunder: caller is not deposit box");
+        _;
+    }
+
+    function bridge(BridgeData memory $) external onlyDepositBox returns (bytes memory result) {
+        require(
+            $.bridgeToken != $.feeToken && $.bridgeToken != NATIVE && $.feeToken != NATIVE,
+            "BridgeFunder: unsupported token"
+        );
+
+        _transferIn($.bridgeToken, msg.sender, $.bridgeAmount);
+        _approveForExtRouter($.bridgeToken, $.bridgeExtRouter, $.bridgeAmount);
+        _approveForExtRouter($.feeToken, $.bridgeExtRouter, $.feeAmount);
+
+        result = $.bridgeExtRouter.functionCall($.bridgeCalldata);
+
+        _approveForExtRouter($.bridgeToken, $.bridgeExtRouter, 0);
+        _approveForExtRouter($.feeToken, $.bridgeExtRouter, 0);
+    }
+
+    function withdraw(address receiver, address token, uint256 amount) external onlyOwner {
+        _transferOut(token, receiver, amount);
+    }
+
+    function _approveForExtRouter(address token, address extRouter, uint256 amount) internal {
+        IERC20(token).forceApprove(extRouter, amount);
+    }
+}

package/contracts/cross-chain/oftImpl/hub/OFTAdapterAltImpl.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import {OFTAdapterImpl} from "./OFTAdapterImpl.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+// @notice Base OFT contract, without any additional functionality (like RateLimiter).
+// @dev This contract inherits Ownable from OpenZeppelin v4.
+// @dev Sender is set as the contract owner at deployment.
+contract OFTAdapterAltImpl is OFTAdapterImpl {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(address _token, address _endpoint, address _delegate) OFTAdapterImpl(_token, _endpoint, _delegate) {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

package/contracts/cross-chain/oftImpl/spoke/PendleBridgedPrincipalTokenAlt.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.19;
+
+import {PendleBridgedPrincipalToken} from "./PendleBridgedPrincipalToken.sol";
+import {
+    MessagingParams,
+    MessagingFee,
+    MessagingReceipt
+} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleBridgedPrincipalTokenAlt is PendleBridgedPrincipalToken {
+    using SafeERC20 for IERC20;
+
+    error MsgValueNotZero(uint256 msgValue);
+    error NativeTokenUnavailable();
+
+    address public immutable nativeToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _delegate,
+        uint256 _expiry,
+        uint8 _localDecimals,
+        uint8 _sharedDecimals,
+        address initialOwner
+    )
+        PendleBridgedPrincipalToken(
+            _name, _symbol, _lzEndpoint, _delegate, _expiry, _localDecimals, _sharedDecimals, initialOwner
+        )
+    {
+        nativeToken = endpoint.nativeToken();
+    }
+
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal override returns (MessagingReceipt memory receipt) {
+        // In Alt implementation, msg.value should always be 0 since we use ERC20 tokens for fees
+        if (msg.value > 0) revert MsgValueNotZero(msg.value);
+
+        // Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
+        _payNative(_fee.nativeFee);
+        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
+
+        return endpoint.send(
+            MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0), _refundAddress
+        );
+    }
+
+    function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
+        if (nativeToken == address(0)) revert NativeTokenUnavailable();
+
+        // Pay Native token fee by sending tokens to the endpoint.
+        IERC20(nativeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+
+        return _nativeFee;
+    }
+}

package/contracts/interfaces/IPAllActionTypeV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.0;
 
 import "../router/swap-aggregator/IPSwapAggregator.sol";
 import "./IPLimitRouter.sol";
+import "./IPYieldToken.sol";
 
 /*
  * NOTICE:

package/contracts/interfaces/IPAllActionV3.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.0;
 
 import "./IPActionAddRemoveLiqV3.sol";
 import "./IPActionCallbackV3.sol";
-import "./IPActionCrossChain.sol";
 import "./IPActionMiscV3.sol";
 import "./IPActionSimple.sol";
 import "./IPActionStorageV4.sol";
@@ -18,6 +17,5 @@ interface IPAllActionV3 is
     IPActionMiscV3,
     IPActionCallbackV3,
     IPActionStorageV4,
-    IPActionSimple,
-    IPActionCrossChain
+    IPActionSimple
 {}

package/contracts/interfaces/IPBridgeFunder.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+struct BridgeData {
+    address bridgeToken;
+    uint256 bridgeAmount;
+    address feeToken;
+    uint256 feeAmount;
+    address bridgeExtRouter;
+    bytes bridgeCalldata;
+}
+
+interface IPBridgeFunder {
+    function bridge(BridgeData memory data) external returns (bytes memory);
+
+    function withdraw(address receiver, address token, uint256 amount) external;
+}

package/contracts/interfaces/IPFixedPricePTAMMV2.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.19;
+
+import {IPChainlinkOracleEssential} from "../interfaces/IPChainlinkOracleEssential.sol";
+import {
+    IERC20MetadataUpgradeable
+} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
+
+interface IPFixedPricePTAMMV2 is IERC20MetadataUpgradeable {
+    event Swap(address indexed caller, address indexed receiver, address PT, uint256 netPtIn, uint256 netTokenOut);
+
+    event PriceOracleUpdated(address indexed PT, address indexed priceOracle);
+
+    event TokenFunded(address indexed sender, uint256 amount);
+
+    event TokenWithdrawn(address indexed sender, uint256 amount);
+
+    event WhitelistUpdated(address indexed user, bool isWhitelisted);
+
+    event PauseStatusUpdated(address indexed PT, bool isPaused);
+
+    function outputToken() external view returns (address);
+
+    function priceOracle(address PT)
+        external
+        view
+        returns (bool isPaused, IPChainlinkOracleEssential, uint256 multiplier);
+
+    function totalPt(address PT) external view returns (uint256);
+
+    function isWhitelisted(address user) external view returns (bool);
+
+    function previewSwapExactPtForToken(address PT, uint256 exactPtIn) external view returns (uint256 amountTokenOut);
+
+    function swapExactPtForToken(address receiver, address PT, uint256 exactPtIn, bytes calldata data)
+        external
+        returns (uint256 netTokenOut);
+
+    // Add/remove funds
+
+    function addFundWhitelisted(uint256 amount) external;
+
+    function removeFund(uint256 amount) external;
+
+    // Admin functions
+
+    function withdrawPt(address PT, uint256 amount) external;
+
+    function setWhitelist(address user, bool isWhitelisted) external;
+
+    function setPriceOracle(address PT, address priceOracle, uint256 multiplier) external;
+
+    function setPausePtTrading(address PT, bool isPaused) external;
+}
+
+interface IPFixedPricePTAMMSwapCallback {
+    function swapCallback(uint256 exactTokenOut, uint256 netPtIn, bytes calldata data) external;
+}

package/contracts/interfaces/IPLimitRouter.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../core/StandardizedYield/PYIndex.sol";
+import "../interfaces/IPAllActionTypeV3.sol";
 
 interface IPLimitOrderType {
     enum OrderType {
@@ -59,6 +60,16 @@ struct FillOrderParams {
     uint256 makingAmount;
 }
 
+struct MintSyData {
+    TokenInput[] inps;
+    uint256[] minSyOuts;
+    uint256 expiry;
+    bytes32 fillParamsHash;
+
+    bytes sig1;
+    bytes sig2;
+}
+
 interface IPLimitRouterCallback is IPLimitOrderType {
     function limitRouterCallback(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory data)
         external
@@ -94,6 +105,9 @@ interface IPLimitRouter is IPLimitOrderType {
     // event added on 2/1/2025
     event LnFeeRateRootsSet(address[] YTs, uint256[] lnFeeRateRoots);
 
+    // event added on 11/3/2026
+    event MintSySignersSet(address signer1, address signer2);
+
     // @dev actualMaking, actualTaking are in the SY form
     function fill(
         FillOrderParams[] memory params,
@@ -105,6 +119,12 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function feeRecipient() external view returns (address);
 
+    function mintSySigner1() external view returns (address);
+
+    function mintSySigner2() external view returns (address);
+
+    function hashFillParams(FillOrderParams[] memory params) external pure returns (bytes32);
+
     function hashOrder(Order memory order) external view returns (bytes32);
 
     function preSignSingle(Order calldata order) external;
@@ -131,6 +151,8 @@ interface IPLimitRouter is IPLimitOrderType {
 
     function WNATIVE() external view returns (address);
 
+    function ROUTER() external view returns (address);
+
     function _checkSig(Order memory order, bytes memory signature)
         external
         view

package/contracts/interfaces/{IPActionCrossChain.sol → IPSwapHelper.sol}

@@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
 
 import {TokenOutput} from "./IPAllActionTypeV3.sol";
 
-interface IPActionCrossChain {
+interface IPSwapHelper {
     function swapWithFixedPricePTAMM(
         address receiver,
         address fixedPricePTAMM,