@uniswap/universal-router-sdk 4.29.3 → 4.29.4

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

@@ -21,15 +21,6 @@ export declare class UniswapTrade implements Command {
     readonly payerIsUser: boolean;
     constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
     get isAllV4(): boolean;
-    /**
-     * Checks if any route in a split trade ends with an ETH-WETH pool.
-     *
-     * When a split trade has routes ending in ETH-WETH pools alongside routes ending in WETH,
-     * V4 swaps that are last in their route must TAKE WETH (not ETH) at the endfor consistency.
-     * This ensures all routes accumulate WETH, which can then be unwrapped together to ETH
-     * in a single operation at the end.
-     */
-    get shouldForceV4UnwrapForSplitNativeOutput(): boolean;
     get inputRequiresWrap(): boolean;
     get inputRequiresUnwrap(): boolean;
     get outputRequiresWrap(): boolean;

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

@@ -703,10 +703,10 @@ var UniswapTrade = /*#__PURE__*/function () {
           addV3Swap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         case routerSdk.Protocol.V4:
-          addV4Swap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody, this.shouldForceV4UnwrapForSplitNativeOutput);
+          addV4Swap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         case routerSdk.Protocol.MIXED:
-          addMixedSwap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody, this.shouldForceV4UnwrapForSplitNativeOutput);
+          addMixedSwap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         default:
           throw new Error('UNSUPPORTED_TRADE_PROTOCOL');
@@ -774,44 +774,6 @@ var UniswapTrade = /*#__PURE__*/function () {
       }
       return result;
     }
-    /**
-     * Checks if any route in a split trade ends with an ETH-WETH pool.
-     *
-     * When a split trade has routes ending in ETH-WETH pools alongside routes ending in WETH,
-     * V4 swaps that are last in their route must TAKE WETH (not ETH) at the endfor consistency.
-     * This ensures all routes accumulate WETH, which can then be unwrapped together to ETH
-     * in a single operation at the end.
-     */
-  }, {
-    key: "shouldForceV4UnwrapForSplitNativeOutput",
-    get: function get() {
-      // Only relevant if output is native and we have split routes
-      if (!this.trade.outputAmount.currency.isNative || this.trade.swaps.length <= 1) {
-        return false;
-      }
-      for (var _iterator3 = _createForOfIteratorHelperLoose(this.trade.swaps), _step3; !(_step3 = _iterator3()).done;) {
-        var swap = _step3.value;
-        if (swap.route.protocol === routerSdk.Protocol.V4) {
-          var v4Route = swap.route;
-          var lastPool = v4Route.pools[v4Route.pools.length - 1];
-          var isEthWethPool = lastPool.currency1.equals(lastPool.currency0.wrapped);
-          if (isEthWethPool) {
-            return true;
-          }
-        } else if (swap.route.protocol === routerSdk.Protocol.MIXED) {
-          var mixedRoute = swap.route;
-          var _lastPool = mixedRoute.pools[mixedRoute.pools.length - 1];
-          // Check if the last pool in the mixed route is a V4 ETH-WETH pool
-          if (_lastPool instanceof v4Sdk.Pool) {
-            var _isEthWethPool = _lastPool.currency1.equals(_lastPool.currency0.wrapped);
-            if (_isEthWethPool) {
-              return true;
-            }
-          }
-        }
-      }
-      return false;
-    }
     // this.trade.swaps is an array of swaps / trades.
     // we are iterating over one swap (trade) at a time so length is 1
     // route is either v2, v3, v4, or mixed
@@ -854,7 +816,21 @@ var UniswapTrade = /*#__PURE__*/function () {
       // if last pool is v4:
       if (lastPool instanceof v4Sdk.Pool) {
         // If output currency is not native but path currency output is native, we need to wrap
-        return !this.trade.outputAmount.currency.isNative && lastRoute.pathOutput.isNative;
+        if (!this.trade.outputAmount.currency.isNative) {
+          if (lastRoute.pathOutput.isNative) {
+            // this means path output is native and we need to wrap
+            return true;
+          } else if (lastPool.currency1.equals(lastPool.currency0.wrapped) && lastRoute.pools.length > 1) {
+            var poolBefore = lastRoute.pools[lastRoute.pools.length - 2];
+            // this means last pool is eth-weth and pool before contains weth
+            if (poolBefore instanceof v4Sdk.Pool && (poolBefore.currency0.equals(lastPool.currency1) || poolBefore.currency1.equals(lastPool.currency1))) {
+              return true;
+            } else if (poolBefore.token0.equals(lastPool.currency1) || poolBefore.token1.equals(lastPool.currency1)) {
+              // same for v2 and v3 pools
+              return true;
+            }
+          }
+        }
       }
       // if last pool is not v4:
       // we do not need to wrap because v2 and v3 pools already require wrapped tokens
@@ -863,18 +839,23 @@ var UniswapTrade = /*#__PURE__*/function () {
   }, {
     key: "outputRequiresUnwrap",
     get: function get() {
-      // If output is ETH and any V4 route has ETH-WETH last pool,
-      // we force ALL V4 routes to take WETH, so we need to unwrap at the end
-      if (this.shouldForceV4UnwrapForSplitNativeOutput) {
-        return true;
-      }
       var swap = this.trade.swaps[0];
       var lastRoute = swap.route;
       var lastPool = lastRoute.pools[lastRoute.pools.length - 1];
       // if last pool is v4:
       if (lastPool instanceof v4Sdk.Pool) {
         // If output currency is native and path currency output is not native, we need to unwrap
-        return this.trade.outputAmount.currency.isNative && !this.trade.swaps[0].route.pathOutput.isNative;
+        if (this.trade.outputAmount.currency.isNative) {
+          if (!this.trade.swaps[0].route.pathOutput.isNative) {
+            // this means path output is weth and we need to unwrap
+            return true;
+          } else if (lastRoute.pools.length > 1 && lastRoute.pools[lastRoute.pools.length - 2] instanceof v4Sdk.Pool && lastRoute.pools[lastRoute.pools.length - 2].currency0.isNative && lastPool.currency1.equals(lastPool.currency0.wrapped)) {
+            // this means last pool is eth-weth and we need to unwrap
+            return true;
+          } else {
+            return false;
+          }
+        }
       }
       // else: if path output currency is native, we need to unwrap because v2 and v3 pools already require wrapped tokens
       return this.trade.outputAmount.currency.isNative;
@@ -924,14 +905,11 @@ function addV3Swap(planner, _ref2, tradeType, options, payerIsUser, routerMustCu
     planner.addCommand(exports.CommandType.V3_SWAP_EXACT_OUT, [routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient, trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), path, payerIsUser]);
   }
 }
-function addV4Swap(planner, _ref3, tradeType, options, payerIsUser, routerMustCustody, shouldForceV4UnwrapForSplitNativeOutput) {
+function addV4Swap(planner, _ref3, tradeType, options, payerIsUser, routerMustCustody) {
   var _options$recipient;
   var inputAmount = _ref3.inputAmount,
     outputAmount = _ref3.outputAmount,
     route = _ref3.route;
-  if (shouldForceV4UnwrapForSplitNativeOutput === void 0) {
-    shouldForceV4UnwrapForSplitNativeOutput = false;
-  }
   // create a deep copy of pools since v4Planner encoding tampers with array
   var pools = route.pools.map(function (p) {
     return p;
@@ -947,21 +925,26 @@ function addV4Swap(planner, _ref3, tradeType, options, payerIsUser, routerMustCu
   var v4Planner = new v4Sdk.V4Planner();
   v4Planner.addTrade(trade, slippageToleranceOnSwap);
   v4Planner.addSettle(trade.route.pathInput, payerIsUser);
-  // If any V4 route in split trades has an ETH-WETH last pool and output is ETH,
-  // ALL V4 routes should use WETH for taking to ensure consistency and allow single unwrap
+  // Handle split route output consistency:
+  // - If output is ETH and some routes output WETH: force all to output WETH, then unwrap
+  // - If output is WETH and some routes output ETH: force all to output ETH, then wrap
   var pathOutputForTake = trade.route.pathOutput;
-  if (shouldForceV4UnwrapForSplitNativeOutput) {
-    pathOutputForTake = pathOutputForTake.wrapped;
+  var lastPool = v4Route.pools[v4Route.pools.length - 1];
+  var ethWethPool = lastPool.currency1.equals(lastPool.currency0.wrapped);
+  if (ethWethPool && v4Route.pools.length > 1) {
+    var poolBefore = v4Route.pools[v4Route.pools.length - 2];
+    if (pathOutputForTake.isNative && poolBefore.currency0.isNative) {
+      pathOutputForTake = pathOutputForTake.wrapped;
+    } else if (!pathOutputForTake.isNative && (poolBefore.currency0.equals(lastPool.currency1) || poolBefore.currency1.equals(lastPool.currency1))) {
+      pathOutputForTake = lastPool.currency0;
+    }
   }
   v4Planner.addTake(pathOutputForTake, 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
-function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMustCustody, shouldForceV4UnwrapForSplitNativeOutput) {
+function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMustCustody) {
   var _options$recipient2;
-  if (shouldForceV4UnwrapForSplitNativeOutput === void 0) {
-    shouldForceV4UnwrapForSplitNativeOutput = false;
-  }
   var route = swap.route;
   var inputAmount = swap.inputAmount;
   var outputAmount = swap.outputAmount;
@@ -969,7 +952,7 @@ function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMust
   // single hop, so it can be reduced to plain swap logic for one protocol version
   if (route.pools.length === 1) {
     if (route.pools[0] instanceof v4Sdk.Pool) {
-      return addV4Swap(planner, swap, tradeType, options, payerIsUser, routerMustCustody, shouldForceV4UnwrapForSplitNativeOutput);
+      return addV4Swap(planner, swap, tradeType, options, payerIsUser, routerMustCustody);
     } else if (route.pools[0] instanceof v3Sdk.Pool) {
       return addV3Swap(planner, swap, tradeType, options, payerIsUser, routerMustCustody);
     } else if (route.pools[0] instanceof v2Sdk.Pair) {
@@ -1019,11 +1002,20 @@ function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMust
         amountIn: 0,
         amountOutMinimum: !isLastSectionInRoute(i) ? 0 : amountOut
       }]);
-      // If any V4 route has ETH-WETH last pool and this is last section outputting ETH,
-      // use WETH instead for consistency
+      // Handle split route output consistency for V4 sections in mixed routes
       var outputTokenForTake = outputToken;
-      if (shouldForceV4UnwrapForSplitNativeOutput && isLastSectionInRoute(i)) {
-        outputTokenForTake = outputToken.wrapped;
+      if (isLastSectionInRoute(i)) {
+        var lastPool = route.pools[route.pools.length - 1];
+        var v4Pool = lastPool instanceof v4Sdk.Pool;
+        var ethWethPool = v4Pool ? lastPool.currency1.equals(lastPool.currency0.wrapped) : false;
+        var poolBefore = route.pools[route.pools.length - 2];
+        if (ethWethPool) {
+          if (outputToken.isNative && poolBefore.token0.isNative) {
+            outputTokenForTake = outputToken.wrapped;
+          } else if (!outputToken.isNative && (poolBefore.token0.equals(lastPool.token1) || poolBefore.token1.equals(lastPool.token1))) {
+            outputTokenForTake = lastPool.token0;
+          }
+        }
       }
       v4Planner.addTake(outputTokenForTake, swapRecipient);
       planner.addCommand(exports.CommandType.V4_SWAP, [v4Planner.finalize()]);