@pendle/core-v2 6.1.2 → 6.1.3-sweed

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

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/180ee41ddd188bb00eb103d1b74d2d9c.json"
+  "buildInfo": "../../../../build-info/9c640f446a230e808e7c4c91e1214a6e.json"
 }

package/contracts/interfaces/IMarketSweed.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPAllActionV3.sol";
+
+interface IMarketSweed {
+    struct ApproxSweedParams {
+        uint256 targetLnImpliedRate;
+        uint256 eps;
+        uint256 maxPtToSwap;
+        int256 guessOffchain;
+        uint256 maxIteration;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap);
+}

package/contracts/interfaces/IPCommonPoolDeployHelperV2.sol

@@ -27,4 +27,13 @@ interface IPCommonPoolDeployHelperV2 is IPPoolDeployHelperV2 {
         uint256 amountToSeed,
         address syOwner
     ) external returns (PoolDeploymentAddrs memory);
+
+    function deployCommonMarketById(
+        bytes32 id,
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory);
 }

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,239 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
+import "../router/base/ActionBase.sol";
+import "../interfaces/IMarketSweed.sol";
+
+contract MarketSweed is ActionBase, IMarketSweed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router, address _dustReceiver) ActionBase(_dustReceiver) {
+        router = _router;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+
+        uint256 netPtOut;
+        (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
+
+        uint256 netYtFromSeed;
+        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens.SY, tokens.YT, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function mintPYFromToken__noCall(
+        address YT,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPYOut) {
+        address SY = IPYieldToken(YT).SY();
+        _mintSyFromToken(YT, SY, 1, input);
+        netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        uint256 netSyDual = 0;
+        if (netPtIn > 0) {
+            /** Add dual SY + PT */
+            uint256 netPtDual;
+            (, , netSyDual, netPtDual) = _readMarket(market).addLiquidity(netSyIn, netPtIn, block.timestamp);
+            if (netPtIn > netPtDual || netSyDual == netSyIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyIn -= netSyDual;
+            _transferOut(YT.PT(), market, netPtDual);
+        }
+
+        PYIndex pyIndex = YT.newIndex();
+        netSyMintPy =
+            (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyMintPy);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity + netSyDual);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+    }
+
+    function _swap(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        ApproxSweedParams memory sweedParams
+    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            int256 amountSyToAccount;
+
+            (guessedSwap, amountSyToAccount) = _calcAmountPtToBuy(state, index, sweedParams);
+            amountPtToAccount = guessedSwap.Uint();
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
+
+            uint256 amountPtToSell = guessedSwap.abs();
+            amountYTToAccount = amountPtToSell;
+
+            _transferOut(address(tokens.SY), address(tokens.YT), index.assetToSyUp(amountPtToSell));
+            uint256 amountPYOut = tokens.YT.mintPY(market, receiver);
+
+            assert(amountPYOut >= amountPtToSell);
+
+            // this amount of SY will be used to add liquidity in later step
+            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
+        }
+    }
+
+    function _calcAmountPtToBuy(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, true)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount + refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return (guess, localAmountSyToAccount);
+            }
+
+            if (localState.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+            }
+        }
+        revert("_calcAmountPtToBuy: failed");
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, false)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount - refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return guess;
+            }
+
+            if (localState.lastLnImpliedRate < sweedParams.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+            }
+        }
+        revert("_calcAmountPtToSell: failed");
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _deepCopy(MarketState memory state) internal pure returns (MarketState memory copiedState) {
+        copiedState.totalPt = state.totalPt;
+        copiedState.totalSy = state.totalSy;
+        copiedState.totalLp = state.totalLp;
+        copiedState.treasury = state.treasury;
+
+        copiedState.scalarRoot = state.scalarRoot;
+        copiedState.expiry = state.expiry;
+
+        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
+        copiedState.reserveFeePercent = state.reserveFeePercent;
+        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
+    }
+
+    function _isValidGuessOffchain(ApproxSweedParams memory sweedParams, bool isBuyingPt) internal pure returns (bool) {
+        if (sweedParams.guessOffchain == 0) return false;
+        if (isBuyingPt != (sweedParams.guessOffchain > 0)) return false;
+        return sweedParams.guessOffchain.abs() <= sweedParams.maxPtToSwap;
+    }
+}

package/contracts/offchain-helpers/deploy/PendleCommonPoolDeployHelperV2.sol

@@ -7,13 +7,15 @@ import "../../interfaces/IOwnable.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnableUpgradeableV2 {
-    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");
-    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");
-    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");
-
-    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY");
-    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY");
-    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY");
+    
+    bytes32 public constant ERC4626_DEPLOY_ID = keccak256("PendleERC4626SYV2");                                     // 0x1278efc0e6754cd30fef2df25ff5ced072ebb194d348b0b1b9548166d24352ef
+    bytes32 public constant ERC4626_NOT_REDEEMABLE_DEPLOY_ID = keccak256("PendleERC4626NotRedeemableToAssetSYV2");  // 0x6f089cd4afdd945c5c26b3f4542d0c294d19ec0e339c6ce4f8eafa94d700d05d
+    bytes32 public constant ERC20_DEPLOY_ID = keccak256("PendleERC20SY");                                           // 0xfcf22a9a515753d83e4f2a81cf368c7226408c64f52411ae95241ebf5ed53304
+    
+    bytes32 public constant ERC4626_WITH_ADAPTER_ID = keccak256("PendleERC4626WithAdapterSY");                      // 0x73f41560741d6765943d3c955034291fe23d9141e3a4719bc97422d5bf019adc
+    bytes32 public constant ERC4626_NO_REDEEM_WITH_ADAPTER_ID = keccak256("PendleERC4626NoRedeemWithAdapterSY");    // 0x3b8dd2b992f773444e5422ba1db289c4657c57110d740dca7975dc095632ef23
+    bytes32 public constant ERC20_WITH_ADAPTER_ID = keccak256("PendleERC20WithAdapterSY");                          // 0xe5cce2b1999bf8c2cc4cf6d96d0569a24d8b782ba1647c09a8e1aa8bbfb98996
+    bytes32 public constant ERC4626_NO_DEPOSIT_NO_REDEEM = keccak256("PendleERC4626NoRedeemNoDepositUpgSY");        // 0x5c1cddc0128e0b02bb711f84a022bf1c13177d4ab028830b702f3a77280025ea
 
     address public immutable syFactory;
 
@@ -31,6 +33,18 @@ contract PendleCommonPoolDeployHelperV2 is PendlePoolDeployHelperV2, BoringOwnab
         __BoringOwnableV2_init(_owner);
     }
 
+    function deployCommonMarketById(
+        bytes32 id,
+        bytes memory constructorParams,
+        PoolConfig memory config,
+        address tokenToSeedLiqudity,
+        uint256 amountToSeed,
+        address syOwner
+    ) external returns (PoolDeploymentAddrs memory) {
+        address SY = IPCommonSYFactory(syFactory).deploySY(id, constructorParams, syOwner);
+        return deploy5115MarketAndSeedLiquidity(SY, config, tokenToSeedLiqudity, amountToSeed);
+    }
+
     // Those 3 are all not payable as they should not accept tokenIn as native
 
     function deployERC4626Market(

package/package.json

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

package/typechain-types/IPCommonPoolDeployHelperV2.ts

@@ -87,6 +87,7 @@ export interface IPCommonPoolDeployHelperV2Interface extends utils.Interface {
   contractName: "IPCommonPoolDeployHelperV2";
   functions: {
     "deploy5115MarketAndSeedLiquidity(address,(uint32,uint256,uint256,uint256,uint256),address,uint256)": FunctionFragment;
+    "deployCommonMarketById(bytes32,bytes,(uint32,uint256,uint256,uint256,uint256),address,uint256,address)": FunctionFragment;
     "deployERC20Market(bytes,(uint32,uint256,uint256,uint256,uint256),address,uint256,address)": FunctionFragment;
     "deployERC4626Market(bytes,(uint32,uint256,uint256,uint256,uint256),address,uint256,address)": FunctionFragment;
     "deployERC4626NotRedeemableMarket(bytes,(uint32,uint256,uint256,uint256,uint256),address,uint256,address)": FunctionFragment;
@@ -101,6 +102,17 @@ export interface IPCommonPoolDeployHelperV2Interface extends utils.Interface {
       BigNumberish
     ]
   ): string;
+  encodeFunctionData(
+    functionFragment: "deployCommonMarketById",
+    values: [
+      BytesLike,
+      BytesLike,
+      IPPoolDeployHelperV2.PoolConfigStruct,
+      string,
+      BigNumberish,
+      string
+    ]
+  ): string;
   encodeFunctionData(
     functionFragment: "deployERC20Market",
     values: [
@@ -136,6 +148,10 @@ export interface IPCommonPoolDeployHelperV2Interface extends utils.Interface {
     functionFragment: "deploy5115MarketAndSeedLiquidity",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "deployCommonMarketById",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "deployERC20Market",
     data: BytesLike
@@ -206,6 +222,16 @@ export interface IPCommonPoolDeployHelperV2 extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    deployCommonMarketById(
+      id: BytesLike,
+      constructorParams: BytesLike,
+      config: IPPoolDeployHelperV2.PoolConfigStruct,
+      tokenToSeedLiqudity: string,
+      amountToSeed: BigNumberish,
+      syOwner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     deployERC20Market(
       constructorParams: BytesLike,
       config: IPPoolDeployHelperV2.PoolConfigStruct,
@@ -242,6 +268,16 @@ export interface IPCommonPoolDeployHelperV2 extends BaseContract {
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  deployCommonMarketById(
+    id: BytesLike,
+    constructorParams: BytesLike,
+    config: IPPoolDeployHelperV2.PoolConfigStruct,
+    tokenToSeedLiqudity: string,
+    amountToSeed: BigNumberish,
+    syOwner: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   deployERC20Market(
     constructorParams: BytesLike,
     config: IPPoolDeployHelperV2.PoolConfigStruct,
@@ -278,6 +314,16 @@ export interface IPCommonPoolDeployHelperV2 extends BaseContract {
       overrides?: CallOverrides
     ): Promise<IPPoolDeployHelperV2.PoolDeploymentAddrsStructOutput>;
 
+    deployCommonMarketById(
+      id: BytesLike,
+      constructorParams: BytesLike,
+      config: IPPoolDeployHelperV2.PoolConfigStruct,
+      tokenToSeedLiqudity: string,
+      amountToSeed: BigNumberish,
+      syOwner: string,
+      overrides?: CallOverrides
+    ): Promise<IPPoolDeployHelperV2.PoolDeploymentAddrsStructOutput>;
+
     deployERC20Market(
       constructorParams: BytesLike,
       config: IPPoolDeployHelperV2.PoolConfigStruct,
@@ -323,6 +369,16 @@ export interface IPCommonPoolDeployHelperV2 extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    deployCommonMarketById(
+      id: BytesLike,
+      constructorParams: BytesLike,
+      config: IPPoolDeployHelperV2.PoolConfigStruct,
+      tokenToSeedLiqudity: string,
+      amountToSeed: BigNumberish,
+      syOwner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     deployERC20Market(
       constructorParams: BytesLike,
       config: IPPoolDeployHelperV2.PoolConfigStruct,
@@ -360,6 +416,16 @@ export interface IPCommonPoolDeployHelperV2 extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    deployCommonMarketById(
+      id: BytesLike,
+      constructorParams: BytesLike,
+      config: IPPoolDeployHelperV2.PoolConfigStruct,
+      tokenToSeedLiqudity: string,
+      amountToSeed: BigNumberish,
+      syOwner: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     deployERC20Market(
       constructorParams: BytesLike,
       config: IPPoolDeployHelperV2.PoolConfigStruct,

package/typechain-types/IPReentrancyGuardUpg.ts

@@ -0,0 +1,89 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  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 IPReentrancyGuardUpgInterface extends utils.Interface {
+  contractName: "IPReentrancyGuardUpg";
+  functions: {
+    "reentrancyGuardEntered()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "reentrancyGuardEntered",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "reentrancyGuardEntered",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IPReentrancyGuardUpg extends BaseContract {
+  contractName: "IPReentrancyGuardUpg";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPReentrancyGuardUpgInterface;
+
+  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: {
+    reentrancyGuardEntered(overrides?: CallOverrides): Promise<[boolean]>;
+  };
+
+  reentrancyGuardEntered(overrides?: CallOverrides): Promise<boolean>;
+
+  callStatic: {
+    reentrancyGuardEntered(overrides?: CallOverrides): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    reentrancyGuardEntered(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    reentrancyGuardEntered(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/typechain-types/MarketSweed.ts

@@ -85,10 +85,15 @@ export declare namespace IMarketSweed {
 export interface MarketSweedInterface extends utils.Interface {
   contractName: "MarketSweed";
   functions: {
+    "mintPYFromToken__noCall(address,(address,uint256,address,address,(uint8,address,bytes,bool)))": FunctionFragment;
     "router()": FunctionFragment;
     "seedAtImpliedRate(address,address,uint256,uint256,(address,uint256,address,address,(uint8,address,bytes,bool)),(uint256,uint256,uint256,int256,uint256))": FunctionFragment;
   };
 
+  encodeFunctionData(
+    functionFragment: "mintPYFromToken__noCall",
+    values: [string, TokenInputStruct]
+  ): string;
   encodeFunctionData(functionFragment: "router", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "seedAtImpliedRate",
@@ -102,6 +107,10 @@ export interface MarketSweedInterface extends utils.Interface {
     ]
   ): string;
 
+  decodeFunctionResult(
+    functionFragment: "mintPYFromToken__noCall",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "seedAtImpliedRate",
@@ -139,6 +148,12 @@ export interface MarketSweed extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
+    mintPYFromToken__noCall(
+      YT: string,
+      input: TokenInputStruct,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     router(overrides?: CallOverrides): Promise<[string]>;
 
     seedAtImpliedRate(
@@ -152,6 +167,12 @@ export interface MarketSweed extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
+  mintPYFromToken__noCall(
+    YT: string,
+    input: TokenInputStruct,
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   router(overrides?: CallOverrides): Promise<string>;
 
   seedAtImpliedRate(
@@ -165,6 +186,12 @@ export interface MarketSweed extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
+    mintPYFromToken__noCall(
+      YT: string,
+      input: TokenInputStruct,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     router(overrides?: CallOverrides): Promise<string>;
 
     seedAtImpliedRate(
@@ -187,6 +214,12 @@ export interface MarketSweed extends BaseContract {
   filters: {};
 
   estimateGas: {
+    mintPYFromToken__noCall(
+      YT: string,
+      input: TokenInputStruct,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     router(overrides?: CallOverrides): Promise<BigNumber>;
 
     seedAtImpliedRate(
@@ -201,6 +234,12 @@ export interface MarketSweed extends BaseContract {
   };
 
   populateTransaction: {
+    mintPYFromToken__noCall(
+      YT: string,
+      input: TokenInputStruct,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     router(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     seedAtImpliedRate(