@dhedge/v2-sdk 2.1.3 → 2.1.4

package/dist/entities/pool.d.ts

@@ -563,4 +563,15 @@ export declare class Pool {
      * @returns {Promise<any>} Transaction
      */
     completeTorosWithdrawal(destinationToken: string, slippage?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
+    /**
+     * Mint PT and YT tokens on Pendle
+     * @param {string} assetFrom Asset to mint from (only underlying asset)
+     * @param {string} pt PT address
+     * @param {BigNumber | string} amountIn Amount underlying asset
+     * @param {number} slippage Slippage tolerance in %
+     * @param {any} options Transaction options
+     * @param {SDKOptions} sdkOptions SDK options including estimateGas
+     * @returns {Promise<any>} Transaction
+     */
+    mintPendle(assetFrom: string, pt: string, amountIn: BigNumber | string, slippage?: number, options?: any, sdkOptions?: SDKOptions): Promise<any>;
 }

package/dist/services/pendle/index.d.ts

@@ -4,4 +4,8 @@ export declare function getPendleSwapTxData(pool: Pool, tokenIn: string, tokenOu
     swapTxData: string;
     minAmountOut: string | null;
 }>;
+export declare function getPendleMintTxData(pool: Pool, tokenIn: string, pt: string, amountIn: ethers.BigNumber | string, slippage: number): Promise<{
+    swapTxData: string;
+    minAmountOut: string | null;
+}>;
 export declare function getMarket(pool: Pool, tokenIn: string, tokenOut: string): Promise<string>;

package/dist/v2-sdk.cjs.development.js

@@ -27041,6 +27041,20 @@ var PTAbi = [
 		],
 		stateMutability: "view",
 		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "YT",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	}
 ];
 
@@ -27136,43 +27150,98 @@ function _getPendleSwapTxData() {
   return _getPendleSwapTxData.apply(this, arguments);
 }
 
+function getPendleMintTxData(_x6, _x7, _x8, _x9, _x10) {
+  return _getPendleMintTxData.apply(this, arguments);
+}
+
+function _getPendleMintTxData() {
+  _getPendleMintTxData = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(pool, tokenIn, pt, amountIn, slippage) {
+    var PTcontract, ytAddress, params, swapResult;
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            PTcontract = new ethers.ethers.Contract(pt, PTAbi, pool.signer);
+            _context4.next = 3;
+            return PTcontract.YT();
+
+          case 3:
+            ytAddress = _context4.sent;
+            params = {
+              receiver: pool.address,
+              tokensIn: tokenIn,
+              tokensOut: pt + "," + ytAddress,
+              amountsIn: amountIn.toString(),
+              slippage: slippage / 100
+            };
+            _context4.prev = 5;
+            _context4.next = 8;
+            return axios.get(pendleBaseUrl + "/v2/sdk/" + networkChainIdMap[pool.network] + "/convert", {
+              params: params
+            });
+
+          case 8:
+            swapResult = _context4.sent;
+            return _context4.abrupt("return", {
+              swapTxData: swapResult.data.routes[0].tx.data,
+              minAmountOut: swapResult.data.routes[0].outputs.filter(function (e) {
+                return e.token === pt.toLowerCase();
+              })[0].amount
+            });
+
+          case 12:
+            _context4.prev = 12;
+            _context4.t0 = _context4["catch"](5);
+            console.error("Error in Pendle API request:", _context4.t0);
+            throw new ApiError("Pendle api request failed");
+
+          case 16:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[5, 12]]);
+  }));
+  return _getPendleMintTxData.apply(this, arguments);
+}
+
 var checkUnderlying = function checkUnderlying(market, token, networkId) {
   if (market.underlyingAsset !== networkId + "-" + token.toLocaleLowerCase()) {
     throw new Error("Can only trade in or out of the underlying asset");
   }
 };
 
-function getMarket(_x6, _x7, _x8) {
+function getMarket(_x11, _x12, _x13) {
   return _getMarket.apply(this, arguments);
 }
 
 function _getMarket() {
-  _getMarket = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(pool, tokenIn, tokenOut) {
+  _getMarket = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(pool, tokenIn, tokenOut) {
     var networkId, marketResult, params, allMarkets, markets;
-    return runtime_1.wrap(function _callee4$(_context4) {
+    return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context4.prev = _context4.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
             networkId = networkChainIdMap[pool.network];
-            _context4.prev = 1;
+            _context5.prev = 1;
             params = {
               isActive: true,
               chainId: networkId
             };
-            _context4.next = 5;
+            _context5.next = 5;
             return axios.get(pendleBaseUrl + "/v1/markets/all", {
               params: params
             });
 
           case 5:
-            marketResult = _context4.sent;
-            _context4.next = 12;
+            marketResult = _context5.sent;
+            _context5.next = 12;
             break;
 
           case 8:
-            _context4.prev = 8;
-            _context4.t0 = _context4["catch"](1);
-            console.error("Error in Pendle API request:", _context4.t0);
+            _context5.prev = 8;
+            _context5.t0 = _context5["catch"](1);
+            console.error("Error in Pendle API request:", _context5.t0);
             throw new ApiError("Pendle api request failed");
 
           case 12:
@@ -27184,31 +27253,31 @@ function _getMarket() {
             });
 
             if (!markets[0]) {
-              _context4.next = 19;
+              _context5.next = 19;
               break;
             }
 
             checkUnderlying(markets[0], tokenOut, networkId);
-            return _context4.abrupt("return", markets[0].address);
+            return _context5.abrupt("return", markets[0].address);
 
           case 19:
             if (!markets[1]) {
-              _context4.next = 24;
+              _context5.next = 24;
               break;
             }
 
             checkUnderlying(markets[1], tokenIn, networkId);
-            return _context4.abrupt("return", markets[1].address);
+            return _context5.abrupt("return", markets[1].address);
 
           case 24:
             throw new Error("Can only trade PT assets");
 
           case 25:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
       }
-    }, _callee4, null, [[1, 8]]);
+    }, _callee5, null, [[1, 8]]);
   }));
   return _getMarket.apply(this, arguments);
 }
@@ -27277,7 +27346,7 @@ var checkExitPostExpPT = /*#__PURE__*/function () {
     }, _callee, null, [[1, 8]]);
   }));
 
-  return function checkExitPostExpPT(_x9, _x10, _x11) {
+  return function checkExitPostExpPT(_x14, _x15, _x16) {
     return _ref.apply(this, arguments);
   };
 }();
@@ -27324,7 +27393,7 @@ var getExitExpPTTxData = /*#__PURE__*/function () {
     }, _callee2);
   }));
 
-  return function getExitExpPTTxData(_x12, _x13, _x14, _x15, _x16) {
+  return function getExitExpPTTxData(_x17, _x18, _x19, _x20, _x21) {
     return _ref2.apply(this, arguments);
   };
 }();
@@ -31523,6 +31592,70 @@ var Pool = /*#__PURE__*/function () {
     }
 
     return completeTorosWithdrawal;
+  }()
+  /**
+   * Mint PT and YT tokens on Pendle
+   * @param {string} assetFrom Asset to mint from (only underlying asset)
+   * @param {string} pt PT address
+   * @param {BigNumber | string} amountIn Amount underlying asset
+   * @param {number} slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @param {SDKOptions} sdkOptions SDK options including estimateGas
+   * @returns {Promise<any>} Transaction
+   */
+  ;
+
+  _proto.mintPendle =
+  /*#__PURE__*/
+  function () {
+    var _mintPendle = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee58(assetFrom, pt, amountIn, slippage, options, sdkOptions) {
+      var _yield$getPendleMintT, swapTxData, minAmountOut, tx;
+
+      return runtime_1.wrap(function _callee58$(_context58) {
+        while (1) {
+          switch (_context58.prev = _context58.next) {
+            case 0:
+              if (slippage === void 0) {
+                slippage = 0.5;
+              }
+
+              if (options === void 0) {
+                options = null;
+              }
+
+              if (sdkOptions === void 0) {
+                sdkOptions = {
+                  estimateGas: false
+                };
+              }
+
+              _context58.next = 5;
+              return getPendleMintTxData(this, assetFrom, pt, amountIn, slippage);
+
+            case 5:
+              _yield$getPendleMintT = _context58.sent;
+              swapTxData = _yield$getPendleMintT.swapTxData;
+              minAmountOut = _yield$getPendleMintT.minAmountOut;
+              _context58.next = 10;
+              return getPoolTxOrGasEstimate(this, [routerAddress[this.network][exports.Dapp.PENDLE], swapTxData, options, minAmountOut], sdkOptions);
+
+            case 10:
+              tx = _context58.sent;
+              return _context58.abrupt("return", tx);
+
+            case 12:
+            case "end":
+              return _context58.stop();
+          }
+        }
+      }, _callee58, this);
+    }));
+
+    function mintPendle(_x273, _x274, _x275, _x276, _x277, _x278) {
+      return _mintPendle.apply(this, arguments);
+    }
+
+    return mintPendle;
   }();
 
   return Pool;