@uniswap/universal-router-sdk 4.6.1 → 4.6.2

package/dist/entities/actions/uniswap.d.ts

@@ -22,6 +22,9 @@ export declare class UniswapTrade implements Command {
     constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
     get isAllV4(): boolean;
     get inputRequiresWrap(): boolean;
+    get inputRequiresUnwrap(): boolean;
+    get outputRequiresWrap(): boolean;
     get outputRequiresUnwrap(): boolean;
+    get outputRequiresTransition(): boolean;
     encode(planner: RoutePlanner, _config: TradeConfig): void;
 }

package/dist/universal-router-sdk.cjs.development.js

@@ -383,17 +383,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 v4Sdk.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 v4Sdk.Pool && pool.token0.wrapped.equals(currency)) {
+    return pool.token0;
+  } else if (pool instanceof v4Sdk.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
 }
 
 (function (RouterActionType) {
@@ -608,6 +604,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 v3Sdk.toHex(fee.multiply(10000).quotient);
 }
@@ -621,7 +621,11 @@ var UniswapTrade = /*#__PURE__*/function () {
     this.options = options;
     this.tradeType = exports.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) {
@@ -630,6 +634,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(exports.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(exports.CommandType.PERMIT2_TRANSFER_FROM, [this.trade.inputAmount.currency.address, ROUTER_AS_RECIPIENT, this.trade.maximumAmountIn(this.options.slippageTolerance).quotient.toString()]);
+      planner.addCommand(exports.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;
@@ -638,7 +646,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 === sdkCore.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) {
@@ -661,11 +669,13 @@ var UniswapTrade = /*#__PURE__*/function () {
     var minimumAmountOut = ethers.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(exports.CommandType.PAY_PORTION, [this.trade.outputAmount.currency.wrapped.address, this.options.fee.recipient, feeBips]);
+        planner.addCommand(exports.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 === sdkCore.TradeType.EXACT_OUTPUT) {
@@ -677,7 +687,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(exports.CommandType.TRANSFER, [this.trade.outputAmount.currency.wrapped.address, this.options.flatFee.recipient, feeAmount]);
+        planner.addCommand(exports.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 === sdkCore.TradeType.EXACT_OUTPUT) {
@@ -688,14 +698,23 @@ var UniswapTrade = /*#__PURE__*/function () {
       // by this if-else clause.
       if (this.outputRequiresUnwrap) {
         planner.addCommand(exports.CommandType.UNWRAP_WETH, [this.options.recipient, minimumAmountOut]);
+      } else if (this.outputRequiresWrap) {
+        planner.addCommand(exports.CommandType.WRAP_ETH, [this.options.recipient, CONTRACT_BALANCE]);
       } else {
-        planner.addCommand(exports.CommandType.SWEEP, [this.trade.outputAmount.currency.wrapped.address, this.options.recipient, minimumAmountOut]);
+        planner.addCommand(exports.CommandType.SWEEP, [getCurrencyAddress(this.trade.outputAmount.currency), this.options.recipient, minimumAmountOut]);
       }
     }
-    if (this.inputRequiresWrap && (this.trade.tradeType === sdkCore.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(exports.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 === sdkCore.TradeType.EXACT_OUTPUT || riskOfPartialFill(this.trade)) {
+      if (this.inputRequiresWrap) {
+        planner.addCommand(exports.CommandType.UNWRAP_WETH, [this.options.recipient, 0]);
+      } else if (this.inputRequiresUnwrap) {
+        planner.addCommand(exports.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(exports.CommandType.SWEEP, [ETH_ADDRESS, this.options.recipient, 0]);
+      }
     }
     if (this.options.safeMode) planner.addCommand(exports.CommandType.SWEEP, [ETH_ADDRESS, this.options.recipient, 0]);
   };
@@ -712,24 +731,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;
 }();
@@ -773,23 +810,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 v4Sdk.Route(pools, inputAmount.currency, outputAmount.currency);
   var trade = v4Sdk.Trade.createUncheckedTrade({
-    route: route,
+    route: v4Route,
     inputAmount: inputAmount,
     outputAmount: outputAmount,
     tradeType: tradeType
   });
   var slippageToleranceOnSwap = routerMustCustody && tradeType == sdkCore.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 v4Sdk.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(exports.CommandType.V4_SWAP, [v4Planner.finalize()]);
 }
 // encode a mixed route swap, i.e. including both v2 and v3 pools