@uniswap/router-sdk 1.0.0-beta.3 → 1.0.0-beta.7

package/dist/router-sdk.esm.js

@@ -1,12 +1,12 @@
 import JSBI from 'jsbi';
 import { Interface } from '@ethersproject/abi';
-import { Multicall, toHex, Payments, Route as Route$1, Trade as Trade$1, encodeRouteToPath, SelfPermit } from '@uniswap/v3-sdk';
 import { abi } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IMulticallExtended.sol/IMulticallExtended.json';
-import { abi as abi$1 } from '@uniswap/swap-router-contracts/artifacts/contracts/interfaces/IPeripheryPaymentsWithFeeExtended.sol/IPeripheryPaymentsWithFeeExtended.json';
+import { Multicall, toHex, Payments, Route as Route$1, Pool, Trade as Trade$1, encodeRouteToPath, SelfPermit } from '@uniswap/v3-sdk';
 import { validateAndParseAddress, TradeType, Fraction, CurrencyAmount, Price, Percent } from '@uniswap/sdk-core';
-import invariant from 'tiny-invariant';
+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/ISwapRouter02.sol/ISwapRouter02.json';
-import { Route, Trade as Trade$2 } from '@uniswap/v2-sdk';
+import { Route, Pair, Trade as Trade$2 } from '@uniswap/v2-sdk';
+import invariant from 'tiny-invariant';
 
 var MSG_SENDER = '0x0000000000000000000000000000000000000000';
 var ADDRESS_THIS = '0x0000000000000000000000000000000000000001';
@@ -39,7 +39,7 @@ var MulticallExtended = /*#__PURE__*/function () {
     } // this means the validation value should be a previousBlockhash
 
 
-    if (typeof validation === 'string') {
+    if (typeof validation === 'string' && validation.startsWith('0x')) {
       var previousBlockhash = validateAndParseBytes32(validation);
       return MulticallExtended.INTERFACE.encodeFunctionData('multicall(bytes32,bytes[])', [previousBlockhash, calldatas]);
     } else {
@@ -52,16 +52,16 @@ var MulticallExtended = /*#__PURE__*/function () {
 }();
 MulticallExtended.INTERFACE = /*#__PURE__*/new Interface(abi);
 
+function encodeFeeBips(fee) {
+  return toHex(fee.multiply(10000).quotient);
+}
+
 var PaymentsExtended = /*#__PURE__*/function () {
   /**
    * Cannot be constructed.
    */
   function PaymentsExtended() {}
 
-  PaymentsExtended.encodeFeeBips = function encodeFeeBips(fee) {
-    return toHex(fee.multiply(10000).quotient);
-  };
-
   PaymentsExtended.encodeUnwrapWETH9 = function encodeUnwrapWETH9(amountMinimum, recipient, feeOptions) {
     // if there's a recipient, just pass it along
     if (typeof recipient === 'string') {
@@ -69,7 +69,7 @@ var PaymentsExtended = /*#__PURE__*/function () {
     }
 
     if (!!feeOptions) {
-      var feeBips = this.encodeFeeBips(feeOptions.fee);
+      var feeBips = encodeFeeBips(feeOptions.fee);
       var feeRecipient = validateAndParseAddress(feeOptions.recipient);
       return PaymentsExtended.INTERFACE.encodeFunctionData('unwrapWETH9WithFee(uint256,uint256,address)', [toHex(amountMinimum), feeBips, feeRecipient]);
     } else {
@@ -84,7 +84,7 @@ var PaymentsExtended = /*#__PURE__*/function () {
     }
 
     if (!!feeOptions) {
-      var feeBips = this.encodeFeeBips(feeOptions.fee);
+      var feeBips = encodeFeeBips(feeOptions.fee);
       var feeRecipient = validateAndParseAddress(feeOptions.recipient);
       return PaymentsExtended.INTERFACE.encodeFunctionData('sweepTokenWithFee(address,uint256,uint256,address)', [token.address, toHex(amountMinimum), feeBips, feeRecipient]);
     } else {
@@ -96,6 +96,10 @@ var PaymentsExtended = /*#__PURE__*/function () {
     return PaymentsExtended.INTERFACE.encodeFunctionData('pull', [token.address, toHex(amount)]);
   };
 
+  PaymentsExtended.encodeWrapETH = function encodeWrapETH(amount) {
+    return PaymentsExtended.INTERFACE.encodeFunctionData('wrapETH', [toHex(amount)]);
+  };
+
   return PaymentsExtended;
 }();
 PaymentsExtended.INTERFACE = /*#__PURE__*/new Interface(abi$1);
@@ -206,6 +210,13 @@ 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 Protocol;
+
+(function (Protocol) {
+  Protocol["V2"] = "V2";
+  Protocol["V3"] = "V3";
+})(Protocol || (Protocol = {}));
+
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -966,13 +977,6 @@ try {
 }
 });
 
-var Protocol;
-
-(function (Protocol) {
-  Protocol["V2"] = "V2";
-  Protocol["V3"] = "V3";
-})(Protocol || (Protocol = {}));
-
 var RouteV2 = /*#__PURE__*/function (_V2RouteSDK) {
   _inheritsLoose(RouteV2, _V2RouteSDK);
 
@@ -1043,7 +1047,43 @@ var Trade = /*#__PURE__*/function () {
       });
     }
 
-    this.tradeType = tradeType;
+    this.tradeType = tradeType; // each route must have the same input and output currency
+
+    var inputCurrency = this.swaps[0].inputAmount.currency;
+    var outputCurrency = this.swaps[0].outputAmount.currency;
+    !this.swaps.every(function (_ref2) {
+      var route = _ref2.route;
+      return inputCurrency.wrapped.equals(route.input.wrapped);
+    }) ? process.env.NODE_ENV !== "production" ? invariant(false, 'INPUT_CURRENCY_MATCH') : invariant(false) : void 0;
+    !this.swaps.every(function (_ref3) {
+      var route = _ref3.route;
+      return outputCurrency.wrapped.equals(route.output.wrapped);
+    }) ? process.env.NODE_ENV !== "production" ? invariant(false, 'OUTPUT_CURRENCY_MATCH') : invariant(false) : void 0; // pools must be unique inter protocols
+
+    var numPools = this.swaps.map(function (_ref4) {
+      var route = _ref4.route;
+      return route.pools.length;
+    }).reduce(function (total, cur) {
+      return total + cur;
+    }, 0);
+    var poolAddressSet = new Set();
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(this.swaps), _step3; !(_step3 = _iterator3()).done;) {
+      var _route2 = _step3.value.route;
+
+      for (var _iterator4 = _createForOfIteratorHelperLoose(_route2.pools), _step4; !(_step4 = _iterator4()).done;) {
+        var pool = _step4.value;
+
+        if (_route2.protocol == Protocol.V3) {
+          poolAddressSet.add(Pool.getAddress(pool.token0, pool.token1, pool.fee));
+        } else {
+          var pair = pool;
+          poolAddressSet.add(Pair.getAddress(pair.token0, pair.token1));
+        }
+      }
+    }
+
+    !(numPools == poolAddressSet.size) ? process.env.NODE_ENV !== "production" ? invariant(false, 'POOLS_DUPLICATED') : invariant(false) : void 0;
   }
 
   var _proto = Trade.prototype;
@@ -1101,7 +1141,7 @@ var Trade = /*#__PURE__*/function () {
 
   Trade.fromRoutes = /*#__PURE__*/function () {
     var _fromRoutes = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(v2Routes, v3Routes, tradeType) {
-      var populatedV2Routes, populatedV3Routes, _iterator3, _step3, _step3$value, routev2, amount, v2Trade, inputAmount, outputAmount, _iterator4, _step4, _step4$value, routev3, _amount, v3Trade, _inputAmount2, _outputAmount2;
+      var populatedV2Routes, populatedV3Routes, _iterator5, _step5, _step5$value, routev2, amount, v2Trade, inputAmount, outputAmount, _iterator6, _step6, _step6$value, routev3, _amount, v3Trade, _inputAmount2, _outputAmount2;
 
       return runtime_1.wrap(function _callee$(_context) {
         while (1) {
@@ -1110,8 +1150,8 @@ var Trade = /*#__PURE__*/function () {
               populatedV2Routes = [];
               populatedV3Routes = [];
 
-              for (_iterator3 = _createForOfIteratorHelperLoose(v2Routes); !(_step3 = _iterator3()).done;) {
-                _step3$value = _step3.value, routev2 = _step3$value.routev2, amount = _step3$value.amount;
+              for (_iterator5 = _createForOfIteratorHelperLoose(v2Routes); !(_step5 = _iterator5()).done;) {
+                _step5$value = _step5.value, routev2 = _step5$value.routev2, amount = _step5$value.amount;
                 v2Trade = new Trade$2(routev2, amount, tradeType);
                 inputAmount = v2Trade.inputAmount, outputAmount = v2Trade.outputAmount;
                 populatedV2Routes.push({
@@ -1121,15 +1161,15 @@ var Trade = /*#__PURE__*/function () {
                 });
               }
 
-              _iterator4 = _createForOfIteratorHelperLoose(v3Routes);
+              _iterator6 = _createForOfIteratorHelperLoose(v3Routes);
 
             case 4:
-              if ((_step4 = _iterator4()).done) {
+              if ((_step6 = _iterator6()).done) {
                 _context.next = 13;
                 break;
               }
 
-              _step4$value = _step4.value, routev3 = _step4$value.routev3, _amount = _step4$value.amount;
+              _step6$value = _step6.value, routev3 = _step6$value.routev3, _amount = _step6$value.amount;
               _context.next = 8;
               return Trade$1.fromRoute(routev3, _amount, tradeType);
 
@@ -1236,8 +1276,8 @@ var Trade = /*#__PURE__*/function () {
       }
 
       var inputCurrency = this.swaps[0].inputAmount.currency;
-      var totalInputFromRoutes = this.swaps.map(function (_ref2) {
-        var inputAmount = _ref2.inputAmount;
+      var totalInputFromRoutes = this.swaps.map(function (_ref5) {
+        var inputAmount = _ref5.inputAmount;
         return inputAmount;
       }).reduce(function (total, cur) {
         return total.add(cur);
@@ -1253,8 +1293,8 @@ var Trade = /*#__PURE__*/function () {
       }
 
       var outputCurrency = this.swaps[0].outputAmount.currency;
-      var totalOutputFromRoutes = this.swaps.map(function (_ref3) {
-        var outputAmount = _ref3.outputAmount;
+      var totalOutputFromRoutes = this.swaps.map(function (_ref6) {
+        var outputAmount = _ref6.outputAmount;
         return outputAmount;
       }).reduce(function (total, cur) {
         return total.add(cur);
@@ -1286,10 +1326,10 @@ var Trade = /*#__PURE__*/function () {
 
       var spotOutputAmount = CurrencyAmount.fromRawAmount(this.outputAmount.currency, 0);
 
-      for (var _iterator5 = _createForOfIteratorHelperLoose(this.swaps), _step5; !(_step5 = _iterator5()).done;) {
-        var _step5$value = _step5.value,
-            route = _step5$value.route,
-            inputAmount = _step5$value.inputAmount;
+      for (var _iterator7 = _createForOfIteratorHelperLoose(this.swaps), _step7; !(_step7 = _iterator7()).done;) {
+        var _step7$value = _step7.value,
+            route = _step7$value.route,
+            inputAmount = _step7$value.inputAmount;
         var midPrice = route.midPrice;
         spotOutputAmount = spotOutputAmount.add(midPrice.quote(inputAmount));
       }
@@ -1303,7 +1343,6 @@ var Trade = /*#__PURE__*/function () {
   return Trade;
 }();
 
-var ZERO$1 = /*#__PURE__*/JSBI.BigInt(0);
 /**
  * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
  */
@@ -1314,18 +1353,16 @@ var SwapRouter = /*#__PURE__*/function () {
    */
   function SwapRouter() {}
 
-  SwapRouter.encodeV2Swap = function encodeV2Swap(trade, options, routerMustCustody) {
+  SwapRouter.encodeV2Swap = function encodeV2Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck) {
     var amountIn = toHex(trade.maximumAmountIn(options.slippageTolerance).quotient);
     var amountOut = toHex(trade.minimumAmountOut(options.slippageTolerance).quotient);
     var path = trade.route.path.map(function (token) {
       return token.address;
     });
-    var recipient = routerMustCustody ? ADDRESS_THIS : options.recipient ? validateAndParseAddress(options.recipient) : MSG_SENDER;
+    var recipient = routerMustCustody ? ADDRESS_THIS : typeof options.recipient === 'undefined' ? MSG_SENDER : validateAndParseAddress(options.recipient);
 
     if (trade.tradeType === TradeType.EXACT_INPUT) {
-      var exactInputParams = [amountIn, // save gas by only passing slippage check if we can't check it later
-      // not a pure win, as sometimes this will cost us more when it would have caused an earlier failure
-      routerMustCustody ? 0 : amountOut, path, recipient];
+      var exactInputParams = [amountIn, performAggregatedSlippageCheck ? 0 : amountOut, path, recipient];
       return SwapRouter.INTERFACE.encodeFunctionData('swapExactTokensForTokens', exactInputParams);
     } else {
       var exactOutputParams = [amountOut, amountIn, path, recipient];
@@ -1333,7 +1370,7 @@ var SwapRouter = /*#__PURE__*/function () {
     }
   };
 
-  SwapRouter.encodeV3Swap = function encodeV3Swap(trade, options, routerMustCustody) {
+  SwapRouter.encodeV3Swap = function encodeV3Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck) {
     var calldatas = [];
 
     for (var _iterator = _createForOfIteratorHelperLoose(trade.swaps), _step; !(_step = _iterator()).done;) {
@@ -1345,7 +1382,7 @@ var SwapRouter = /*#__PURE__*/function () {
       var amountOut = toHex(trade.minimumAmountOut(options.slippageTolerance, outputAmount).quotient); // flag for whether the trade is single hop or not
 
       var singleHop = route.pools.length === 1;
-      var recipient = routerMustCustody ? ADDRESS_THIS : options.recipient ? validateAndParseAddress(options.recipient) : MSG_SENDER;
+      var recipient = routerMustCustody ? ADDRESS_THIS : typeof options.recipient === 'undefined' ? MSG_SENDER : validateAndParseAddress(options.recipient);
 
       if (singleHop) {
         if (trade.tradeType === TradeType.EXACT_INPUT) {
@@ -1355,7 +1392,7 @@ var SwapRouter = /*#__PURE__*/function () {
             fee: route.pools[0].fee,
             recipient: recipient,
             amountIn: amountIn,
-            amountOutMinimum: amountOut,
+            amountOutMinimum: performAggregatedSlippageCheck ? 0 : amountOut,
             sqrtPriceLimitX96: 0
           };
           calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInputSingle', [exactInputSingleParams]));
@@ -1379,7 +1416,7 @@ var SwapRouter = /*#__PURE__*/function () {
             path: path,
             recipient: recipient,
             amountIn: amountIn,
-            amountOutMinimum: amountOut
+            amountOutMinimum: performAggregatedSlippageCheck ? 0 : amountOut
           };
           calldatas.push(SwapRouter.INTERFACE.encodeFunctionData('exactInput', [exactInputParams]));
         } else {
@@ -1436,6 +1473,9 @@ var SwapRouter = /*#__PURE__*/function () {
       trades = [trades];
     }
 
+    var numberOfTrades = trades.reduce(function (numberOfTrades, trade) {
+      return numberOfTrades + (trade instanceof Trade$1 ? trade.swaps.length : 1);
+    }, 0);
     var sampleTrade = trades[0]; // All trades should have the same starting/ending currency and trade type
 
     !trades.every(function (trade) {
@@ -1457,13 +1497,17 @@ var SwapRouter = /*#__PURE__*/function () {
     var outputIsNative = sampleTrade.outputAmount.currency.isNative; // flag for whether a refund needs to happen
     //   1. when paying in ETH, but with an uncertain input amount
 
-    var mustRefund = inputIsNative && sampleTrade.tradeType === TradeType.EXACT_OUTPUT; // flag for whether funds should be send first to the router
+    var mustRefund = inputIsNative && sampleTrade.tradeType === TradeType.EXACT_OUTPUT; // flag for whether we want to perform an aggregated slippage check
+    //   1. when there are >2 exact input trades. this is only a heuristic,
+    //      as it's still more gas-expensive even in this case, but has benefits
+    //      in that the reversion probability is lower
+
+    var performAggregatedSlippageCheck = sampleTrade.tradeType === TradeType.EXACT_INPUT && numberOfTrades > 2; // flag for whether funds should be send first to the router
     //   1. when receiving ETH (which much be unwrapped from WETH)
     //   2. when a fee on the output is being taken
-    //   3. when there are >1 exact input trades. this one isn't strictly necessary,
-    //      but typically we want to perform an aggregated slippage check
+    //   3. when performing an aggregated slippage check
 
-    var routerMustCustody = outputIsNative || !!options.fee || trades.length > 1 && sampleTrade.tradeType === TradeType.EXACT_INPUT;
+    var routerMustCustody = outputIsNative || !!options.fee || performAggregatedSlippageCheck;
     var totalValue = inputIsNative ? trades.reduce(function (sum, trade) {
       return sum.add(trade.maximumAmountIn(options.slippageTolerance));
     }, ZERO_IN) : ZERO_IN; // encode permit if necessary
@@ -1477,25 +1521,21 @@ var SwapRouter = /*#__PURE__*/function () {
       var trade = _step3.value;
 
       if (trade instanceof Trade$2) {
-        calldatas.push(SwapRouter.encodeV2Swap(trade, options, routerMustCustody));
+        calldatas.push(SwapRouter.encodeV2Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck));
       } else {
-        for (var _iterator4 = _createForOfIteratorHelperLoose(SwapRouter.encodeV3Swap(trade, options, routerMustCustody)), _step4; !(_step4 = _iterator4()).done;) {
+        for (var _iterator4 = _createForOfIteratorHelperLoose(SwapRouter.encodeV3Swap(trade, options, routerMustCustody, performAggregatedSlippageCheck)), _step4; !(_step4 = _iterator4()).done;) {
           var calldata = _step4.value;
           calldatas.push(calldata);
         }
       }
-    } // unwrap
+    } // unwrap or sweep
 
 
     if (routerMustCustody) {
-      // if all trades are exact output, we can save gas by not passing a slippage check
-      var canOmitSlippageCheck = sampleTrade.tradeType === TradeType.EXACT_OUTPUT;
-      var amountNecessary = canOmitSlippageCheck ? ZERO$1 : totalAmountOut.quotient;
-
       if (outputIsNative) {
-        calldatas.push(PaymentsExtended.encodeUnwrapWETH9(amountNecessary, options.recipient, options.fee));
+        calldatas.push(PaymentsExtended.encodeUnwrapWETH9(totalAmountOut.quotient, options.recipient, options.fee));
       } else {
-        calldatas.push(PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, amountNecessary, options.recipient, options.fee));
+        calldatas.push(PaymentsExtended.encodeSweepToken(sampleTrade.outputAmount.currency.wrapped, totalAmountOut.quotient, options.recipient, options.fee));
       }
     } // refund