@pendle/core-v2 3.0.0-beta-9 → 3.0.0-beta-11

package/contracts/router/{base/ActionBaseCallback.sol → ActionCallbackV3.sol}

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IPMarketFactory.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../core/libraries/Errors.sol";
+import "../interfaces/IPActionCallbackV3.sol";
+import "../core/libraries/Errors.sol";
+import "./base/CallbackHelper.sol";
 
-import "./MarketApproxLib.sol";
-import "./CallbackHelper.sol";
-import "../../core/libraries/TokenHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "../core/libraries/TokenHelper.sol";
 
-abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
+contract ActionCallbackV3 is IPOrderMixinType, IPActionCallbackV3, CallbackHelper, TokenHelper {
     using PMath for int256;
     using PMath for uint256;
     using PYIndexLib for PYIndex;
@@ -32,6 +28,58 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         }
     }
 
+    function normalFillCallback(uint256 actualMaking, uint256 actualTaking, uint256, /*totalFee*/ bytes memory data)
+        external
+        returns (
+            bytes memory // encode as netTransferToLimit, netOutputFromLimit
+        )
+    {
+        (OrderType orderType, IPYieldToken YT, uint256 netRemaining, address receiver) =
+            abi.decode(data, (OrderType, IPYieldToken, uint256, address));
+
+        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
+            PYIndex index = YT.newIndex();
+            uint256 totalSyToMintPy = index.assetToSyUp(actualTaking);
+            uint256 additionalSyToMint = totalSyToMintPy - actualMaking;
+
+            require(additionalSyToMint <= netRemaining, "Router: Max SY to pull exceeded");
+
+            _transferOut(YT.SY(), address(YT), additionalSyToMint);
+
+            uint256 netPyToReceiver;
+            if (orderType == OrderType.SY_FOR_PT) {
+                netPyToReceiver = YT.mintPY(address(this), receiver);
+                _safeApproveInf(YT.PT(), msg.sender);
+            } else {
+                netPyToReceiver = YT.mintPY(receiver, address(this));
+                _safeApproveInf(address(YT), msg.sender);
+            }
+
+            return abi.encode(additionalSyToMint, netPyToReceiver);
+        } else {
+            require(actualMaking <= netRemaining, "Router: Max PY to pull exceeded");
+
+            if (orderType == OrderType.PT_FOR_SY) {
+                _transferOut(address(YT), address(YT), actualMaking);
+            } else {
+                _transferOut(YT.PT(), address(YT), actualMaking);
+            }
+
+            uint256 netSyRedeemed = IPYieldToken(YT).redeemPY(address(this));
+
+            require(actualTaking <= netSyRedeemed, "Router: Insufficient SY redeemed");
+
+            uint256 netSyToReceiver = netSyRedeemed - actualTaking;
+
+            address SY = YT.SY();
+
+            _transferOut(SY, receiver, netSyToReceiver);
+            _safeApproveInf(SY, msg.sender);
+
+            return abi.encode(actualMaking, netSyToReceiver);
+        }
+    }
+
     function _callbackSwapExactSyForYt(int256 ptToAccount, int256, /*syToAccount*/ bytes calldata data) internal {
         (address receiver, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
 

package/contracts/router/ActionMiscV3.sol

@@ -2,10 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "./base/SimulateHelper.sol";
 import "../interfaces/IPActionMiscV3.sol";
 
-contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
+contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     function mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata input)
         external
         payable
@@ -148,16 +147,8 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase, SimulateHelper {
         }
     }
 
-    function multicallRevert(uint256 gasLimit, bytes[] calldata callDatas)
-        public
-        payable
-        override(IPActionMiscV3, SimulateHelper)
-        returns (bytes[] memory res, uint256[] memory gasUsed)
-    {
-        return super.multicallRevert(gasLimit, callDatas);
-    }
-
-    function callThenRevert(bytes memory callData) public payable override(IPActionMiscV3, SimulateHelper) {
-        return super.callThenRevert(callData);
+    function simulate(address target, bytes calldata data) external payable {
+        (bool success, bytes memory result) = target.delegatecall(data);
+        revert Errors.SimulationResults(success, result);
     }
 }

package/contracts/router/ActionSwapYTV3.sol

@@ -2,10 +2,10 @@
 pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
-import "./base/ActionBaseCallback.sol";
+import "./base/CallbackHelper.sol";
 import "../interfaces/IPActionSwapYTV3.sol";
 
-contract ActionSwapYTV3 is ActionBaseCallback, IPActionSwapYTV3, ActionBase {
+contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
     using PMath for uint256;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;

package/contracts/router/PendleRouterV3.sol

@@ -12,6 +12,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
     address internal immutable ACTION_SWAP_PT;
     address internal immutable ACTION_SWAP_YT;
     address internal immutable ACTION_MISC;
+    address internal immutable ACTION_CALLBACK;
 
     event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
 
@@ -19,12 +20,14 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
         address _ACTION_ADD_REMOVE_LIQ,
         address _ACTION_SWAP_PT,
         address _ACTION_SWAP_YT,
-        address _ACTION_MISC
+        address _ACTION_MISC,
+        address _ACTION_CALLBACK
     ) {
         ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
         ACTION_SWAP_PT = _ACTION_SWAP_PT;
         ACTION_SWAP_YT = _ACTION_SWAP_YT;
         ACTION_MISC = _ACTION_MISC;
+        ACTION_CALLBACK = _ACTION_CALLBACK;
         _emitEvents();
     }
 
@@ -88,14 +91,13 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
             res[11] = 0xef03bda7; // addLiquiditySinglePt
         }
         if (facet == ACTION_SWAP_YT) {
-            res = new bytes4[](7);
+            res = new bytes4[](6);
             res[0] = 0x0a793c62; // swapExactYtForSy
             res[1] = 0x448b9b95; // swapExactYtForPt
             res[2] = 0x7e0646c4; // swapExactYtForToken
             res[3] = 0x9c1010ec; // swapExactTokenForYt
             res[4] = 0xc861a898; // swapExactPtForYt
             res[5] = 0xf80915bc; // swapExactSyForYt
-            res[6] = 0xfa483e72; // swapCallback
         }
         if (facet == ACTION_SWAP_PT) {
             res = new bytes4[](4);
@@ -104,92 +106,96 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
             res[2] = 0x7a95dddd; // swapExactPtForSy
             res[3] = 0xc245e48d; // swapExactPtForToken
         }
+        if (facet == ACTION_CALLBACK) {
+            res = new bytes4[](2);
+            res[0] = 0xb5617576; // normalFillCallback
+            res[1] = 0xfa483e72; // swapCallback
+        }
         if (facet == ACTION_MISC) {
-            res = new bytes4[](13);
+            res = new bytes4[](12);
             res[0] = 0x1a8631b2; // mintPyFromSy
-            res[1] = 0x1cf0f536; // callThenRevert
-            res[2] = 0x2d8f9d8d; // boostMarkets
-            res[3] = 0x2e071dc6; // mintSyFromToken
-            res[4] = 0x339748cb; // redeemPyToSy
-            res[5] = 0x339a5572; // redeemSyToToken
-            res[6] = 0x47f1de22; // redeemPyToToken
-            res[7] = 0x5d3e105c; // swapTokenToToken
-            res[8] = 0x60fc8466; // multicall
-            res[9] = 0x657b87d8; // multicallRevert
-            res[10] = 0xa89eba4a; // swapTokenToTokenViaSy
-            res[11] = 0xd0f42385; // mintPyFromToken
-            res[12] = 0xf7e375e8; // redeemDueInterestAndRewards
+            res[1] = 0x2d8f9d8d; // boostMarkets
+            res[2] = 0x2e071dc6; // mintSyFromToken
+            res[3] = 0x339748cb; // redeemPyToSy
+            res[4] = 0x339a5572; // redeemSyToToken
+            res[5] = 0x47f1de22; // redeemPyToToken
+            res[6] = 0x5d3e105c; // swapTokenToToken
+            res[7] = 0x60fc8466; // multicall
+            res[8] = 0xa89eba4a; // swapTokenToTokenViaSy
+            res[9] = 0xbd61951d; // simulate
+            res[10] = 0xd0f42385; // mintPyFromToken
+            res[11] = 0xf7e375e8; // redeemDueInterestAndRewards
         }
     }
 
     function facetAddress(bytes4 sig) public view returns (address) {
-        if (sig < 0x7a0ed627) {
-            if (sig < 0x339a5572) {
-                if (sig < 0x2756ce06) {
+        if (sig < 0x7e0646c4) {
+            if (sig < 0x3dbe1c55) {
+                if (sig < 0x2d8f9d8d) {
                     if (sig < 0x1a8631b2) {
                         if (sig == 0x0a793c62) return ACTION_SWAP_YT; //swapExactYtForSy
                         if (sig == 0x12c15afc) return ACTION_SWAP_PT; //swapExactSyForPt
                     } else {
                         if (sig == 0x1a8631b2) return ACTION_MISC; //mintPyFromSy
-                        if (sig == 0x1cf0f536) return ACTION_MISC; //callThenRevert
                         if (sig == 0x237287c8) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySinglePt
+                        if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
                     }
                 } else {
-                    if (sig < 0x2e071dc6) {
-                        if (sig == 0x2756ce06) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualTokenAndPt
+                    if (sig < 0x32aea98a) {
                         if (sig == 0x2d8f9d8d) return ACTION_MISC; //boostMarkets
-                    } else {
                         if (sig == 0x2e071dc6) return ACTION_MISC; //mintSyFromToken
+                    } else {
                         if (sig == 0x32aea98a) return ACTION_SWAP_PT; //swapExactTokenForPt
                         if (sig == 0x339748cb) return ACTION_MISC; //redeemPyToSy
+                        if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
                     }
                 }
             } else {
-                if (sig < 0x587e3950) {
-                    if (sig < 0x448b9b95) {
-                        if (sig == 0x339a5572) return ACTION_MISC; //redeemSyToToken
+                if (sig < 0x5a245eef) {
+                    if (sig < 0x47f1de22) {
                         if (sig == 0x3dbe1c55) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleTokenKeepYt
-                    } else {
                         if (sig == 0x448b9b95) return ACTION_SWAP_YT; //swapExactYtForPt
+                    } else {
                         if (sig == 0x47f1de22) return ACTION_MISC; //redeemPyToToken
                         if (sig == 0x52ef6b2c) return address(this); //facetAddresses
+                        if (sig == 0x587e3950) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
                     }
                 } else {
-                    if (sig < 0x5d3e105c) {
-                        if (sig == 0x587e3950) return ACTION_ADD_REMOVE_LIQ; //removeLiquiditySingleToken
+                    if (sig < 0x60fc8466) {
                         if (sig == 0x5a245eef) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSy
-                    } else {
                         if (sig == 0x5d3e105c) return ACTION_MISC; //swapTokenToToken
+                    } else {
                         if (sig == 0x60fc8466) return ACTION_MISC; //multicall
-                        if (sig == 0x657b87d8) return ACTION_MISC; //multicallRevert
+                        if (sig == 0x7a0ed627) return address(this); //facets
+                        if (sig == 0x7a95dddd) return ACTION_SWAP_PT; //swapExactPtForSy
                     }
                 }
             }
         } else {
-            if (sig < 0xb7d75b8b) {
-                if (sig < 0x9c1010ec) {
-                    if (sig < 0x7e0646c4) {
-                        if (sig == 0x7a0ed627) return address(this); //facets
-                        if (sig == 0x7a95dddd) return ACTION_SWAP_PT; //swapExactPtForSy
-                    } else {
+            if (sig < 0xbd61951d) {
+                if (sig < 0xa89eba4a) {
+                    if (sig < 0x97ee279e) {
                         if (sig == 0x7e0646c4) return ACTION_SWAP_YT; //swapExactYtForToken
                         if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleSyKeepYt
+                    } else {
                         if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; //addLiquidityDualSyAndPt
-                    }
-                } else {
-                    if (sig < 0xa89eba4a) {
                         if (sig == 0x9c1010ec) return ACTION_SWAP_YT; //swapExactTokenForYt
                         if (sig == 0x9cb6711e) return ACTION_ADD_REMOVE_LIQ; //addLiquiditySingleToken
-                    } else {
+                    }
+                } else {
+                    if (sig < 0xb00f09d7) {
                         if (sig == 0xa89eba4a) return ACTION_MISC; //swapTokenToTokenViaSy
                         if (sig == 0xadfca15e) return address(this); //facetFunctionSelectors
+                    } else {
                         if (sig == 0xb00f09d7) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualTokenAndPt
+                        if (sig == 0xb5617576) return ACTION_CALLBACK; //normalFillCallback
+                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
                     }
                 }
             } else {
                 if (sig < 0xe81560a4) {
                     if (sig < 0xc861a898) {
-                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; //removeLiquidityDualSyAndPt
+                        if (sig == 0xbd61951d) return ACTION_MISC; //simulate
                         if (sig == 0xc245e48d) return ACTION_SWAP_PT; //swapExactPtForToken
                     } else {
                         if (sig == 0xc861a898) return ACTION_SWAP_YT; //swapExactPtForYt
@@ -203,7 +209,7 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
                     } else {
                         if (sig == 0xf7e375e8) return ACTION_MISC; //redeemDueInterestAndRewards
                         if (sig == 0xf80915bc) return ACTION_SWAP_YT; //swapExactSyForYt
-                        if (sig == 0xfa483e72) return ACTION_SWAP_YT; //swapCallback
+                        if (sig == 0xfa483e72) return ACTION_CALLBACK; //swapCallback
                     }
                 }
             }
@@ -213,12 +219,13 @@ contract PendleRouterV3 is Proxy, IDiamondLoupe {
     }
 
     function facetAddresses() public view returns (address[] memory) {
-        address[] memory res = new address[](5);
+        address[] memory res = new address[](6);
         res[0] = address(this);
         res[1] = ACTION_ADD_REMOVE_LIQ;
         res[2] = ACTION_SWAP_YT;
         res[3] = ACTION_SWAP_PT;
-        res[4] = ACTION_MISC;
+        res[4] = ACTION_CALLBACK;
+        res[5] = ACTION_MISC;
         return res;
     }
 

package/contracts/router/base/ActionBase.sol

@@ -11,10 +11,11 @@ import "../../router/base/MarketApproxLib.sol";
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
 
-abstract contract ActionBase is TokenHelper {
+abstract contract ActionBase is TokenHelper, IPOrderMixinType {
     using MarketApproxPtOutLib for MarketState;
     using PMath for uint256;
     using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
 
     bytes internal constant EMPTY_BYTES = abi.encode();
 
@@ -214,10 +215,9 @@ abstract contract ActionBase is TokenHelper {
         IPLimitRouter router = IPLimitRouter(lim.limitRouter);
         netLeft = netInput;
 
-        _safeApproveInf(address(tokenIn), lim.limitRouter);
-
         if (lim.normalFills.length != 0) {
-            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) =
+            _safeApproveInf(address(tokenIn), lim.limitRouter);
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee,) =
                 router.normalFill(lim.normalFills, receiver, netLeft, EMPTY_BYTES);
             netOut += actualMaking;
             netSyFee += totalFee;
@@ -225,11 +225,16 @@ abstract contract ActionBase is TokenHelper {
         }
 
         if (lim.flashFills.length != 0) {
-            (uint256 totalOutput, uint256 totalInput, uint256 totalFee) =
-                router.flashFill(lim.flashFills, receiver, netLeft, EMPTY_BYTES);
-            netOut += totalOutput;
+            address YT = lim.flashFills[0].order.YT;
+            OrderType orderType = lim.flashFills[0].order.orderType;
+
+            (,, uint256 totalFee, bytes memory ret) =
+                router.normalFill(lim.flashFills, YT, type(uint256).max, abi.encode(orderType, YT, netLeft, receiver));
+            (uint256 netUse, uint256 netReceived) = abi.decode(ret, (uint256, uint256));
+
+            netOut += netReceived;
             netSyFee += totalFee;
-            netLeft -= totalInput;
+            netLeft -= netUse;
         }
 
         doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);

package/deployments/42161-core.json

@@ -31,5 +31,6 @@
     "limitRouter": "0xF5d582f126Ca43E0247Ce5260c2b545260e09b70",
     "proxyAdmin": "0xb699508D2384039e06f5535Ec8a48e7829ca7724",
     "arbMerkleDistribution": "0x23a102e78D1FF1645a3666691495174764a5FCAF",
-    "linearDistributor": "0x83d85AEDD308261d847C3eb8d7146457bD8F38E8"
+    "linearDistributor": "0x83d85AEDD308261d847C3eb8d7146457bD8F38E8",
+    "limitBackendHelper": "0xa3b3442D8f9ceb45D87b5f32115d94e9b7FcB114"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "3.0.0-beta-9",
+  "version": "3.0.0-beta-11",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/ActionCallbackV3.ts

@@ -0,0 +1,164 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface ActionCallbackV3Interface extends utils.Interface {
+  contractName: "ActionCallbackV3";
+  functions: {
+    "normalFillCallback(uint256,uint256,uint256,bytes)": FunctionFragment;
+    "swapCallback(int256,int256,bytes)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "normalFillCallback",
+    values: [BigNumberish, BigNumberish, BigNumberish, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapCallback",
+    values: [BigNumberish, BigNumberish, BytesLike]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "normalFillCallback",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapCallback",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface ActionCallbackV3 extends BaseContract {
+  contractName: "ActionCallbackV3";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ActionCallbackV3Interface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    normalFillCallback(
+      actualMaking: BigNumberish,
+      actualTaking: BigNumberish,
+      arg2: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapCallback(
+      ptToAccount: BigNumberish,
+      syToAccount: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  normalFillCallback(
+    actualMaking: BigNumberish,
+    actualTaking: BigNumberish,
+    arg2: BigNumberish,
+    data: BytesLike,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapCallback(
+    ptToAccount: BigNumberish,
+    syToAccount: BigNumberish,
+    data: BytesLike,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    normalFillCallback(
+      actualMaking: BigNumberish,
+      actualTaking: BigNumberish,
+      arg2: BigNumberish,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    swapCallback(
+      ptToAccount: BigNumberish,
+      syToAccount: BigNumberish,
+      data: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    normalFillCallback(
+      actualMaking: BigNumberish,
+      actualTaking: BigNumberish,
+      arg2: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    swapCallback(
+      ptToAccount: BigNumberish,
+      syToAccount: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    normalFillCallback(
+      actualMaking: BigNumberish,
+      actualTaking: BigNumberish,
+      arg2: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapCallback(
+      ptToAccount: BigNumberish,
+      syToAccount: BigNumberish,
+      data: BytesLike,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}