@uniswap/universal-router-sdk 4.6.1 → 4.7.0

package/dist/universal-router-sdk.esm.js

@@ -3,7 +3,7 @@ import { abi } from '@uniswap/universal-router/artifacts/contracts/UniversalRout
 import { Interface } from '@ethersproject/abi';
 import { BigNumber, ethers } from 'ethers';
 import { toHex, Trade as Trade$1, encodeRouteToPath, Pool as Pool$1, NonfungiblePositionManager, Multicall, Route as Route$1 } from '@uniswap/v3-sdk';
-import { Pool, Trade as Trade$2, V4Planner, Route, Actions, encodeRouteToPath as encodeRouteToPath$1, V4PositionManager, V4BaseActionsParser } from '@uniswap/v4-sdk';
+import { Pool, Route, Trade as Trade$2, V4Planner, Actions, encodeRouteToPath as encodeRouteToPath$1, V4PositionManager, V4BaseActionsParser } from '@uniswap/v4-sdk';
 import { TradeType, Percent, validateAndParseAddress, CHAIN_TO_ADDRESSES_MAP, CurrencyAmount, Ether, Token } from '@uniswap/sdk-core';
 import { defaultAbiCoder } from 'ethers/lib/utils';
 import { Trade, Pair, Route as Route$2 } from '@uniswap/v2-sdk';
@@ -385,17 +385,13 @@ function getPathCurrency(currency, pool) {
   } else if (pool.involvesToken(currency.wrapped)) {
     return currency.wrapped;
     // return native currency if pool involves native version of wrapped currency (only applies to V4)
-  } else if (pool instanceof Pool) {
-    if (pool.token0.wrapped.equals(currency)) {
-      return pool.token0;
-    } else if (pool.token1.wrapped.equals(currency)) {
-      return pool.token1;
-    }
-    // otherwise the token is invalid
+  } else if (pool instanceof Pool && pool.token0.wrapped.equals(currency)) {
+    return pool.token0;
+  } else if (pool instanceof Pool && pool.token1.wrapped.equals(currency)) {
+    return pool.token1;
   } else {
     throw new Error("Expected currency " + currency.symbol + " to be either " + pool.token0.symbol + " or " + pool.token1.symbol);
   }
-  return currency; // this line needed for typescript to compile
 }
 
 var RouterActionType;
@@ -404,7 +400,7 @@ var RouterActionType;
   RouterActionType["UnwrapWETH"] = "UnwrapWETH";
 })(RouterActionType || (RouterActionType = {}));
 
-var _routerConfigs, _routerConfigs2, _routerConfigs3, _routerConfigs4, _routerConfigs5, _routerConfigs6, _routerConfigs7, _routerConfigs8, _routerConfigs9, _routerConfigs10, _routerConfigs11, _routerConfigs12, _routerConfigs13, _routerConfigs14, _routerConfigs15, _routerConfigs16, _routerConfigs17, _routerConfigs18, _routerConfigs19, _routerConfigs20, _CHAIN_CONFIGS;
+var _routerConfigs, _routerConfigs2, _routerConfigs3, _routerConfigs4, _routerConfigs5, _routerConfigs6, _routerConfigs7, _routerConfigs8, _routerConfigs9, _routerConfigs10, _routerConfigs11, _routerConfigs12, _routerConfigs13, _routerConfigs14, _routerConfigs15, _routerConfigs16, _routerConfigs17, _routerConfigs18, _routerConfigs19, _routerConfigs20, _routerConfigs21, _CHAIN_CONFIGS;
 var UniversalRouterVersion;
 (function (UniversalRouterVersion) {
   UniversalRouterVersion["V1_2"] = "1.2";
@@ -592,6 +588,15 @@ var CHAIN_CONFIGS = (_CHAIN_CONFIGS = {}, _CHAIN_CONFIGS[1] = {
     address: '0xcA7577Afb670147c7b211C798B97118bd36058F3',
     creationBlock: 1490973
   }, _routerConfigs20)
+}, _CHAIN_CONFIGS[130] = {
+  weth: '0x4200000000000000000000000000000000000006',
+  routerConfigs: (_routerConfigs21 = {}, _routerConfigs21[UniversalRouterVersion.V1_2] = {
+    address: '0x4D73A4411CA1c660035e4AECC8270E5DdDEC8C17',
+    creationBlock: 23678
+  }, _routerConfigs21[UniversalRouterVersion.V2_0] = {
+    address: '0x4D73A4411CA1c660035e4AECC8270E5DdDEC8C17',
+    creationBlock: 23678
+  }, _routerConfigs21)
 }, _CHAIN_CONFIGS);
 var UNIVERSAL_ROUTER_ADDRESS = function UNIVERSAL_ROUTER_ADDRESS(version, chainId) {
   if (!(chainId in CHAIN_CONFIGS)) throw new Error("Universal Router not deployed on chain " + chainId);
@@ -612,6 +617,10 @@ var E_ETH_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
 var SENDER_AS_RECIPIENT = '0x0000000000000000000000000000000000000001';
 var ROUTER_AS_RECIPIENT = '0x0000000000000000000000000000000000000002';
 
+function getCurrencyAddress(currency) {
+  return currency.isNative ? ETH_ADDRESS : currency.wrapped.address;
+}
+
 function encodeFeeBips(fee) {
   return toHex(fee.multiply(10000).quotient);
 }
@@ -625,7 +634,11 @@ var UniswapTrade = /*#__PURE__*/function () {
     this.options = options;
     this.tradeType = RouterActionType.UniswapTrade;
     if (!!options.fee && !!options.flatFee) throw new Error('Only one fee option permitted');
-    if (this.inputRequiresWrap) this.payerIsUser = false;else if (this.options.useRouterBalance) this.payerIsUser = false;else this.payerIsUser = true;
+    if (this.inputRequiresWrap || this.inputRequiresUnwrap || this.options.useRouterBalance) {
+      this.payerIsUser = false;
+    } else {
+      this.payerIsUser = true;
+    }
   }
   var _proto = UniswapTrade.prototype;
   _proto.encode = function encode(planner, _config) {
@@ -634,6 +647,10 @@ var UniswapTrade = /*#__PURE__*/function () {
     if (this.inputRequiresWrap) {
       // TODO: optimize if only one v2 pool we can directly send this to the pool
       planner.addCommand(CommandType.WRAP_ETH, [ROUTER_AS_RECIPIENT, this.trade.maximumAmountIn(this.options.slippageTolerance).quotient.toString()]);
+    } else if (this.inputRequiresUnwrap) {
+      // send wrapped token to router to unwrap
+      planner.addCommand(CommandType.PERMIT2_TRANSFER_FROM, [this.trade.inputAmount.currency.address, ROUTER_AS_RECIPIENT, this.trade.maximumAmountIn(this.options.slippageTolerance).quotient.toString()]);
+      planner.addCommand(CommandType.UNWRAP_WETH, [ROUTER_AS_RECIPIENT, 0]);
     }
     // The overall recipient at the end of the trade, SENDER_AS_RECIPIENT uses the msg.sender
     this.options.recipient = (_this$options$recipie = this.options.recipient) != null ? _this$options$recipie : SENDER_AS_RECIPIENT;
@@ -642,7 +659,7 @@ var UniswapTrade = /*#__PURE__*/function () {
     //      as it's still more gas-expensive even in this case, but has benefits
     //      in that the reversion probability is lower
     var performAggregatedSlippageCheck = this.trade.tradeType === TradeType.EXACT_INPUT && this.trade.routes.length > 2;
-    var routerMustCustody = performAggregatedSlippageCheck || this.outputRequiresUnwrap || hasFeeOption(this.options);
+    var routerMustCustody = performAggregatedSlippageCheck || this.outputRequiresTransition || hasFeeOption(this.options);
     for (var _iterator = _createForOfIteratorHelperLoose(this.trade.swaps), _step; !(_step = _iterator()).done;) {
       var swap = _step.value;
       switch (swap.route.protocol) {
@@ -665,11 +682,13 @@ var UniswapTrade = /*#__PURE__*/function () {
     var minimumAmountOut = BigNumber.from(this.trade.minimumAmountOut(this.options.slippageTolerance).quotient.toString());
     // The router custodies for 3 reasons: to unwrap, to take a fee, and/or to do a slippage check
     if (routerMustCustody) {
+      var pools = this.trade.swaps[0].route.pools;
+      var pathOutputCurrencyAddress = getCurrencyAddress(getPathCurrency(this.trade.outputAmount.currency, pools[pools.length - 1]));
       // If there is a fee, that percentage is sent to the fee recipient
       // In the case where ETH is the output currency, the fee is taken in WETH (for gas reasons)
       if (!!this.options.fee) {
         var feeBips = encodeFeeBips(this.options.fee.fee);
-        planner.addCommand(CommandType.PAY_PORTION, [this.trade.outputAmount.currency.wrapped.address, this.options.fee.recipient, feeBips]);
+        planner.addCommand(CommandType.PAY_PORTION, [pathOutputCurrencyAddress, this.options.fee.recipient, feeBips]);
         // If the trade is exact output, and a fee was taken, we must adjust the amount out to be the amount after the fee
         // Otherwise we continue as expected with the trade's normal expected output
         if (this.trade.tradeType === TradeType.EXACT_OUTPUT) {
@@ -681,7 +700,7 @@ var UniswapTrade = /*#__PURE__*/function () {
       if (!!this.options.flatFee) {
         var feeAmount = this.options.flatFee.amount;
         if (minimumAmountOut.lt(feeAmount)) throw new Error('Flat fee amount greater than minimumAmountOut');
-        planner.addCommand(CommandType.TRANSFER, [this.trade.outputAmount.currency.wrapped.address, this.options.flatFee.recipient, feeAmount]);
+        planner.addCommand(CommandType.TRANSFER, [pathOutputCurrencyAddress, this.options.flatFee.recipient, feeAmount]);
         // If the trade is exact output, and a fee was taken, we must adjust the amount out to be the amount after the fee
         // Otherwise we continue as expected with the trade's normal expected output
         if (this.trade.tradeType === TradeType.EXACT_OUTPUT) {
@@ -692,14 +711,23 @@ var UniswapTrade = /*#__PURE__*/function () {
       // by this if-else clause.
       if (this.outputRequiresUnwrap) {
         planner.addCommand(CommandType.UNWRAP_WETH, [this.options.recipient, minimumAmountOut]);
+      } else if (this.outputRequiresWrap) {
+        planner.addCommand(CommandType.WRAP_ETH, [this.options.recipient, CONTRACT_BALANCE]);
       } else {
-        planner.addCommand(CommandType.SWEEP, [this.trade.outputAmount.currency.wrapped.address, this.options.recipient, minimumAmountOut]);
+        planner.addCommand(CommandType.SWEEP, [getCurrencyAddress(this.trade.outputAmount.currency), this.options.recipient, minimumAmountOut]);
       }
     }
-    if (this.inputRequiresWrap && (this.trade.tradeType === TradeType.EXACT_OUTPUT || riskOfPartialFill(this.trade))) {
-      // for exactOutput swaps that take native currency as input
-      // we need to send back the change to the user
-      planner.addCommand(CommandType.UNWRAP_WETH, [this.options.recipient, 0]);
+    // for exactOutput swaps with native input or that perform an inputToken transition (wrap or unwrap)
+    // we need to send back the change to the user
+    if (this.trade.tradeType === TradeType.EXACT_OUTPUT || riskOfPartialFill(this.trade)) {
+      if (this.inputRequiresWrap) {
+        planner.addCommand(CommandType.UNWRAP_WETH, [this.options.recipient, 0]);
+      } else if (this.inputRequiresUnwrap) {
+        planner.addCommand(CommandType.WRAP_ETH, [this.options.recipient, CONTRACT_BALANCE]);
+      } else if (this.trade.inputAmount.currency.isNative) {
+        // must refund extra native currency sent along for native v4 trades (no input transition)
+        planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, this.options.recipient, 0]);
+      }
     }
     if (this.options.safeMode) planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, this.options.recipient, 0]);
   };
@@ -716,24 +744,42 @@ var UniswapTrade = /*#__PURE__*/function () {
   }, {
     key: "inputRequiresWrap",
     get: function get() {
-      if (!this.isAllV4) {
-        return this.trade.inputAmount.currency.isNative;
+      if (this.isAllV4) {
+        return this.trade.inputAmount.currency.isNative && !this.trade.swaps[0].route.pathInput.isNative;
       } else {
-        // We only support wrapping all ETH or no ETH currently. We cannot support splitting where half needs to be wrapped
-        // If the input currency is ETH and the input of the first path is not ETH it must be WETH that needs wrapping
-        return this.trade.inputAmount.currency.isNative && !this.trade.swaps[0].route.input.isNative;
+        return this.trade.inputAmount.currency.isNative;
+      }
+    }
+  }, {
+    key: "inputRequiresUnwrap",
+    get: function get() {
+      if (this.isAllV4) {
+        return !this.trade.inputAmount.currency.isNative && this.trade.swaps[0].route.pathInput.isNative;
       }
+      return false;
+    }
+  }, {
+    key: "outputRequiresWrap",
+    get: function get() {
+      if (this.isAllV4) {
+        return !this.trade.outputAmount.currency.isNative && this.trade.swaps[0].route.pathOutput.isNative;
+      }
+      return false;
     }
   }, {
     key: "outputRequiresUnwrap",
     get: function get() {
-      if (!this.isAllV4) {
-        return this.trade.outputAmount.currency.isNative;
+      if (this.isAllV4) {
+        return this.trade.outputAmount.currency.isNative && !this.trade.swaps[0].route.pathOutput.isNative;
       } else {
-        // If the output currency is ETH and the output of the swap is not ETH it must be WETH that needs unwrapping
-        return this.trade.outputAmount.currency.isNative && !this.trade.swaps[0].route.output.isNative;
+        return this.trade.outputAmount.currency.isNative;
       }
     }
+  }, {
+    key: "outputRequiresTransition",
+    get: function get() {
+      return this.outputRequiresWrap || this.outputRequiresUnwrap;
+    }
   }]);
   return UniswapTrade;
 }();
@@ -777,23 +823,25 @@ function addV3Swap(planner, _ref2, tradeType, options, payerIsUser, routerMustCu
 }
 function addV4Swap(planner, _ref3, tradeType, options, payerIsUser, routerMustCustody) {
   var _options$recipient;
-  var route = _ref3.route,
-    inputAmount = _ref3.inputAmount,
-    outputAmount = _ref3.outputAmount;
+  var inputAmount = _ref3.inputAmount,
+    outputAmount = _ref3.outputAmount,
+    route = _ref3.route;
+  // create a deep copy of pools since v4Planner encoding tampers with array
+  var pools = route.pools.map(function (p) {
+    return p;
+  });
+  var v4Route = new Route(pools, inputAmount.currency, outputAmount.currency);
   var trade = Trade$2.createUncheckedTrade({
-    route: route,
+    route: v4Route,
     inputAmount: inputAmount,
     outputAmount: outputAmount,
     tradeType: tradeType
   });
   var slippageToleranceOnSwap = routerMustCustody && tradeType == TradeType.EXACT_INPUT ? undefined : options.slippageTolerance;
-  var inputWethFromRouter = inputAmount.currency.isNative && !route.input.isNative;
-  if (inputWethFromRouter && !payerIsUser) throw new Error('Inconsistent payer');
   var v4Planner = new V4Planner();
   v4Planner.addTrade(trade, slippageToleranceOnSwap);
-  v4Planner.addSettle(inputWethFromRouter ? inputAmount.currency.wrapped : inputAmount.currency, payerIsUser);
-  options.recipient = (_options$recipient = options.recipient) != null ? _options$recipient : SENDER_AS_RECIPIENT;
-  v4Planner.addTake(outputAmount.currency, routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient);
+  v4Planner.addSettle(trade.route.pathInput, payerIsUser);
+  v4Planner.addTake(trade.route.pathOutput, routerMustCustody ? ROUTER_AS_RECIPIENT : (_options$recipient = options.recipient) != null ? _options$recipient : SENDER_AS_RECIPIENT);
   planner.addCommand(CommandType.V4_SWAP, [v4Planner.finalize()]);
 }
 // encode a mixed route swap, i.e. including both v2 and v3 pools