@uniswap/router-sdk 1.0.1 → 1.0.5

package/dist/router-sdk.esm.js

@@ -1,19 +1,137 @@
 import JSBI from 'jsbi';
 import { Interface } from '@ethersproject/abi';
-import { abi } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json';
-import { Multicall, toHex, Payments, NonfungiblePositionManager, Route as Route$1, Pool, Trade as Trade$1, encodeRouteToPath, SelfPermit } from '@uniswap/v3-sdk';
+import invariant from 'tiny-invariant';
+import { abi } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IApproveAndCall.sol/IApproveAndCall.json';
+import { NonfungiblePositionManager, toHex, Multicall, Payments, Route as Route$1, Pool, Trade as Trade$1, encodeRouteToPath, SelfPermit, Position } from '@uniswap/v3-sdk';
+import { abi as abi$1 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json';
 import { validateAndParseAddress, TradeType, Fraction, CurrencyAmount, Price, Percent, WETH9 } from '@uniswap/sdk-core';
-import { abi as abi$1 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IPeripheryPaymentsWithFeeExtended.sol/IPeripheryPaymentsWithFeeExtended.json';
+import { abi as abi$2 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IPeripheryPaymentsWithFeeExtended.sol/IPeripheryPaymentsWithFeeExtended.json';
 import { abi as abi$3 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/ISwapRouter02.sol/ISwapRouter02.json';
 import { Route, Pair, Trade as Trade$2 } from '@uniswap/v2-sdk';
-import invariant from 'tiny-invariant';
-import { abi as abi$2 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IApproveAndCall.sol/IApproveAndCall.json';
 
 var MSG_SENDER = '0x0000000000000000000000000000000000000001';
 var ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
 var ZERO = /*#__PURE__*/JSBI.BigInt(0);
 var ONE = /*#__PURE__*/JSBI.BigInt(1);
 
+var ApprovalTypes;
+
+(function (ApprovalTypes) {
+  ApprovalTypes[ApprovalTypes["NOT_REQUIRED"] = 0] = "NOT_REQUIRED";
+  ApprovalTypes[ApprovalTypes["MAX"] = 1] = "MAX";
+  ApprovalTypes[ApprovalTypes["MAX_MINUS_ONE"] = 2] = "MAX_MINUS_ONE";
+  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX"] = 3] = "ZERO_THEN_MAX";
+  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX_MINUS_ONE"] = 4] = "ZERO_THEN_MAX_MINUS_ONE";
+})(ApprovalTypes || (ApprovalTypes = {})); // type guard
+
+
+function isMint(options) {
+  return Object.keys(options).some(function (k) {
+    return k === 'recipient';
+  });
+}
+var ApproveAndCall = /*#__PURE__*/function () {
+  /**
+   * Cannot be constructed.
+   */
+  function ApproveAndCall() {}
+
+  ApproveAndCall.encodeApproveMax = function encodeApproveMax(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMax', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveMaxMinusOne = function encodeApproveMaxMinusOne(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMaxMinusOne', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveZeroThenMax = function encodeApproveZeroThenMax(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMax', [token.address]);
+  };
+
+  ApproveAndCall.encodeApproveZeroThenMaxMinusOne = function encodeApproveZeroThenMaxMinusOne(token) {
+    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMaxMinusOne', [token.address]);
+  };
+
+  ApproveAndCall.encodeCallPositionManager = function encodeCallPositionManager(calldatas) {
+    !(calldatas.length > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'NULL_CALLDATA') : invariant(false) : void 0;
+
+    if (calldatas.length == 1) {
+      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', calldatas);
+    } else {
+      var encodedMulticall = NonfungiblePositionManager.INTERFACE.encodeFunctionData('multicall', [calldatas]);
+      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', [encodedMulticall]);
+    }
+  }
+  /**
+   * Encode adding liquidity to a position in the nft manager contract
+   * @param position Forcasted position with expected amount out from swap
+   * @param minimalPosition Forcasted position with custom minimal token amounts
+   * @param addLiquidityOptions Options for adding liquidity
+   * @param slippageTolerance Defines maximum slippage
+   */
+  ;
+
+  ApproveAndCall.encodeAddLiquidity = function encodeAddLiquidity(position, minimalPosition, addLiquidityOptions, slippageTolerance) {
+    var _position$mintAmounts = position.mintAmountsWithSlippage(slippageTolerance),
+        amount0Min = _position$mintAmounts.amount0,
+        amount1Min = _position$mintAmounts.amount1; // position.mintAmountsWithSlippage() can create amounts not dependenable in scenarios
+    // such as range orders. Allow the option to provide a position with custom minimum amounts
+    // for these scenarios
+
+
+    if (JSBI.lessThan(minimalPosition.amount0.quotient, amount0Min)) {
+      amount0Min = minimalPosition.amount0.quotient;
+    }
+
+    if (JSBI.lessThan(minimalPosition.amount1.quotient, amount1Min)) {
+      amount1Min = minimalPosition.amount1.quotient;
+    }
+
+    if (isMint(addLiquidityOptions)) {
+      return ApproveAndCall.INTERFACE.encodeFunctionData('mint', [{
+        token0: position.pool.token0.address,
+        token1: position.pool.token1.address,
+        fee: position.pool.fee,
+        tickLower: position.tickLower,
+        tickUpper: position.tickUpper,
+        amount0Min: toHex(amount0Min),
+        amount1Min: toHex(amount1Min),
+        recipient: addLiquidityOptions.recipient
+      }]);
+    } else {
+      return ApproveAndCall.INTERFACE.encodeFunctionData('increaseLiquidity', [{
+        token0: position.pool.token0.address,
+        token1: position.pool.token1.address,
+        amount0Min: toHex(amount0Min),
+        amount1Min: toHex(amount1Min),
+        tokenId: toHex(addLiquidityOptions.tokenId)
+      }]);
+    }
+  };
+
+  ApproveAndCall.encodeApprove = function encodeApprove(token, approvalType) {
+    switch (approvalType) {
+      case ApprovalTypes.MAX:
+        return ApproveAndCall.encodeApproveMax(token.wrapped);
+
+      case ApprovalTypes.MAX_MINUS_ONE:
+        return ApproveAndCall.encodeApproveMaxMinusOne(token.wrapped);
+
+      case ApprovalTypes.ZERO_THEN_MAX:
+        return ApproveAndCall.encodeApproveZeroThenMax(token.wrapped);
+
+      case ApprovalTypes.ZERO_THEN_MAX_MINUS_ONE:
+        return ApproveAndCall.encodeApproveZeroThenMaxMinusOne(token.wrapped);
+
+      default:
+        throw 'Error: invalid ApprovalType';
+    }
+  };
+
+  return ApproveAndCall;
+}();
+ApproveAndCall.INTERFACE = /*#__PURE__*/new Interface(abi);
+
 function validateAndParseBytes32(bytes32) {
   if (!bytes32.match(/^0x[0-9a-fA-F]{64}$/)) {
     throw new Error(bytes32 + " is not valid bytes32.");
@@ -51,7 +169,7 @@ var MulticallExtended = /*#__PURE__*/function () {
 
   return MulticallExtended;
 }();
-MulticallExtended.INTERFACE = /*#__PURE__*/new Interface(abi);
+MulticallExtended.INTERFACE = /*#__PURE__*/new Interface(abi$1);
 
 function encodeFeeBips(fee) {
   return toHex(fee.multiply(10000).quotient);
@@ -103,7 +221,7 @@ var PaymentsExtended = /*#__PURE__*/function () {
 
   return PaymentsExtended;
 }();
-PaymentsExtended.INTERFACE = /*#__PURE__*/new Interface(abi$1);
+PaymentsExtended.INTERFACE = /*#__PURE__*/new Interface(abi$2);
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -211,72 +329,6 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
   throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-var ApprovalTypes;
-
-(function (ApprovalTypes) {
-  ApprovalTypes[ApprovalTypes["NOT_REQUIRED"] = 0] = "NOT_REQUIRED";
-  ApprovalTypes[ApprovalTypes["MAX"] = 1] = "MAX";
-  ApprovalTypes[ApprovalTypes["MAX_MINUS_ONE"] = 2] = "MAX_MINUS_ONE";
-  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX"] = 3] = "ZERO_THEN_MAX";
-  ApprovalTypes[ApprovalTypes["ZERO_THEN_MAX_MINUS_ONE"] = 4] = "ZERO_THEN_MAX_MINUS_ONE";
-})(ApprovalTypes || (ApprovalTypes = {}));
-
-var ApproveAndCall = /*#__PURE__*/function () {
-  /**
-   * Cannot be constructed.
-   */
-  function ApproveAndCall() {}
-
-  ApproveAndCall.encodeApproveMax = function encodeApproveMax(token) {
-    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMax', [token.address]);
-  };
-
-  ApproveAndCall.encodeApproveMaxMinusOne = function encodeApproveMaxMinusOne(token) {
-    return ApproveAndCall.INTERFACE.encodeFunctionData('approveMaxMinusOne', [token.address]);
-  };
-
-  ApproveAndCall.encodeApproveZeroThenMax = function encodeApproveZeroThenMax(token) {
-    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMax', [token.address]);
-  };
-
-  ApproveAndCall.encodeApproveZeroThenMaxMinusOne = function encodeApproveZeroThenMaxMinusOne(token) {
-    return ApproveAndCall.INTERFACE.encodeFunctionData('approveZeroThenMaxMinusOne', [token.address]);
-  };
-
-  ApproveAndCall.encodeCallPositionManager = function encodeCallPositionManager(calldatas) {
-    !(calldatas.length > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'NULL_CALLDATA') : invariant(false) : void 0;
-
-    if (calldatas.length == 1) {
-      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', calldatas);
-    } else {
-      var encodedMulticall = NonfungiblePositionManager.INTERFACE.encodeFunctionData('multicall', [calldatas]);
-      return ApproveAndCall.INTERFACE.encodeFunctionData('callPositionManager', [encodedMulticall]);
-    }
-  };
-
-  ApproveAndCall.encodeApprove = function encodeApprove(token, approvalType) {
-    switch (approvalType) {
-      case ApprovalTypes.MAX:
-        return ApproveAndCall.encodeApproveMax(token.wrapped);
-
-      case ApprovalTypes.MAX_MINUS_ONE:
-        return ApproveAndCall.encodeApproveMaxMinusOne(token.wrapped);
-
-      case ApprovalTypes.ZERO_THEN_MAX:
-        return ApproveAndCall.encodeApproveZeroThenMax(token.wrapped);
-
-      case ApprovalTypes.ZERO_THEN_MAX_MINUS_ONE:
-        return ApproveAndCall.encodeApproveZeroThenMaxMinusOne(token.wrapped);
-
-      default:
-        throw 'Error: invalid ApprovalType';
-    }
-  };
-
-  return ApproveAndCall;
-}();
-ApproveAndCall.INTERFACE = /*#__PURE__*/new Interface(abi$2);
-
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -1584,9 +1636,12 @@ var SwapRouter = /*#__PURE__*/function () {
 
     var ZERO_IN = CurrencyAmount.fromRawAmount(sampleTrade.inputAmount.currency, 0);
     var ZERO_OUT = CurrencyAmount.fromRawAmount(sampleTrade.outputAmount.currency, 0);
-    var totalAmountOut = trades.reduce(function (sum, trade) {
+    var minimumAmountOut = trades.reduce(function (sum, trade) {
       return sum.add(trade.minimumAmountOut(options.slippageTolerance));
     }, ZERO_OUT);
+    var quoteAmountOut = trades.reduce(function (sum, trade) {
+      return sum.add(trade.outputAmount);
+    }, ZERO_OUT);
     var totalAmountIn = trades.reduce(function (sum, trade) {
       return sum.add(trade.maximumAmountIn(options.slippageTolerance));
     }, ZERO_IN);
@@ -1597,7 +1652,8 @@ var SwapRouter = /*#__PURE__*/function () {
       inputIsNative: inputIsNative,
       outputIsNative: outputIsNative,
       totalAmountIn: totalAmountIn,
-      totalAmountOut: totalAmountOut
+      minimumAmountOut: minimumAmountOut,
+      quoteAmountOut: quoteAmountOut
     };
   }
   /**
@@ -1615,14 +1671,14 @@ var SwapRouter = /*#__PURE__*/function () {
         inputIsNative = _SwapRouter$encodeSwa.inputIsNative,
         outputIsNative = _SwapRouter$encodeSwa.outputIsNative,
         totalAmountIn = _SwapRouter$encodeSwa.totalAmountIn,
-        totalAmountOut = _SwapRouter$encodeSwa.totalAmountOut; // unwrap or sweep
+        minimumAmountOut = _SwapRouter$encodeSwa.minimumAmountOut; // unwrap or sweep
 
 
     if (routerMustCustody) {
       if (outputIsNative) {
-        calldatas.push(PaymentsExtended.encodeUnwrapWETH9(totalAmountOut.quotient, options.recipient, options.fee));
+        calldatas.push(PaymentsExtended.encodeUnwrapWETH9(minimumAmountOut.quotient, options.recipient, options.fee));
       } else {
-        calldatas.push(PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, totalAmountOut.quotient, options.recipient, options.fee));
+        calldatas.push(PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, minimumAmountOut.quotient, options.recipient, options.fee));
       }
     } // must refund when paying in ETH, but with an uncertain input amount
 
@@ -1650,10 +1706,17 @@ var SwapRouter = /*#__PURE__*/function () {
         outputIsNative = _SwapRouter$encodeSwa2.outputIsNative,
         sampleTrade = _SwapRouter$encodeSwa2.sampleTrade,
         totalAmountSwapped = _SwapRouter$encodeSwa2.totalAmountIn,
-        totalAmountOut = _SwapRouter$encodeSwa2.totalAmountOut;
+        quoteAmountOut = _SwapRouter$encodeSwa2.quoteAmountOut,
+        minimumAmountOut = _SwapRouter$encodeSwa2.minimumAmountOut; // encode output token permit if necessary
+
+
+    if (options.outputTokenPermit) {
+      !quoteAmountOut.currency.isToken ? process.env.NODE_ENV !== "production" ? invariant(false, 'NON_TOKEN_PERMIT_OUTPUT') : invariant(false) : void 0;
+      calldatas.push(SelfPermit.encodePermit(quoteAmountOut.currency, options.outputTokenPermit));
+    }
 
     var chainId = sampleTrade.route.chainId;
-    var zeroForOne = position.pool.token0 === totalAmountSwapped.currency.wrapped;
+    var zeroForOne = position.pool.token0.wrapped.address === totalAmountSwapped.currency.wrapped.address;
 
     var _SwapRouter$getPositi = SwapRouter.getPositionAmounts(position, zeroForOne),
         positionAmountIn = _SwapRouter$getPositi.positionAmountIn,
@@ -1663,7 +1726,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var tokenIn = inputIsNative ? WETH9[chainId] : positionAmountIn.currency.wrapped;
     var tokenOut = outputIsNative ? WETH9[chainId] : positionAmountOut.currency.wrapped; // if swap output does not make up whole outputTokenBalanceDesired, pull in remaining tokens for adding liquidity
 
-    var amountOutRemaining = positionAmountOut.subtract(totalAmountOut.wrapped);
+    var amountOutRemaining = positionAmountOut.subtract(quoteAmountOut.wrapped);
 
     if (amountOutRemaining.greaterThan(CurrencyAmount.fromRawAmount(positionAmountOut.currency, 0))) {
       // if output is native, this means the remaining portion is included as native value in the transaction
@@ -1675,9 +1738,19 @@ var SwapRouter = /*#__PURE__*/function () {
     inputIsNative ? calldatas.push(PaymentsExtended.encodeWrapETH(positionAmountIn.quotient)) : calldatas.push(PaymentsExtended.encodePull(tokenIn, positionAmountIn.quotient)); // approve token balances to NFTManager
 
     if (tokenInApprovalType !== ApprovalTypes.NOT_REQUIRED) calldatas.push(ApproveAndCall.encodeApprove(tokenIn, tokenInApprovalType));
-    if (tokenOutApprovalType !== ApprovalTypes.NOT_REQUIRED) calldatas.push(ApproveAndCall.encodeApprove(tokenOut, tokenOutApprovalType)); // encode NFTManager add liquidity
+    if (tokenOutApprovalType !== ApprovalTypes.NOT_REQUIRED) calldatas.push(ApproveAndCall.encodeApprove(tokenOut, tokenOutApprovalType)); // represents a position with token amounts resulting from a swap with maximum slippage
+    // hence the minimal amount out possible.
+
+    var minimalPosition = Position.fromAmounts({
+      pool: position.pool,
+      tickLower: position.tickLower,
+      tickUpper: position.tickUpper,
+      amount0: zeroForOne ? position.amount0.quotient.toString() : minimumAmountOut.quotient.toString(),
+      amount1: zeroForOne ? minimumAmountOut.quotient.toString() : position.amount1.quotient.toString(),
+      useFullPrecision: false
+    }); // encode NFTManager add liquidity
 
-    calldatas.push(ApproveAndCall.encodeCallPositionManager([NonfungiblePositionManager.addCallParameters(position, addLiquidityOptions).calldata])); // sweep remaining tokens
+    calldatas.push(ApproveAndCall.encodeAddLiquidity(position, minimalPosition, addLiquidityOptions, options.slippageTolerance)); // sweep remaining tokens
 
     inputIsNative ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO$1)) : calldatas.push(PaymentsExtended.encodeSweepToken(tokenIn, ZERO$1));
     outputIsNative ? calldatas.push(PaymentsExtended.encodeUnwrapWETH9(ZERO$1)) : calldatas.push(PaymentsExtended.encodeSweepToken(tokenOut, ZERO$1));
@@ -1718,5 +1791,5 @@ var SwapRouter = /*#__PURE__*/function () {
 }();
 SwapRouter.INTERFACE = /*#__PURE__*/new Interface(abi$3);
 
-export { ADDRESS_THIS, MSG_SENDER, MulticallExtended, ONE, PaymentsExtended, Protocol, RouteV2, RouteV3, SwapRouter, Trade, ZERO };
+export { ADDRESS_THIS, ApprovalTypes, ApproveAndCall, MSG_SENDER, MulticallExtended, ONE, PaymentsExtended, Protocol, RouteV2, RouteV3, SwapRouter, Trade, ZERO, isMint };
 //# sourceMappingURL=router-sdk.esm.js.map