@uniswap/router-sdk 1.21.4 → 1.22.1

package/dist/entities/mixedRoute/route.d.ts

@@ -18,8 +18,9 @@ export declare class MixedRouteSDK<TInput extends Currency, TOutput extends Curr
      * @param pools An array of `TPool` objects (pools or pairs), ordered by the route the swap will take
      * @param input The input token
      * @param output The output token
+     * @param retainsFakePool Set to true to filter out a pool that has a fake eth-weth pool
      */
-    constructor(pools: TPool[], input: TInput, output: TOutput);
+    constructor(pools: TPool[], input: TInput, output: TOutput, retainFakePools?: boolean);
     get chainId(): number;
     /**
      * Returns the mid price of the route

package/dist/entities/route.d.ts

@@ -4,6 +4,7 @@ import { Route as V4RouteSDK, Pool as V4Pool } from '@uniswap/v4-sdk';
 import { Protocol } from './protocol';
 import { Currency, Price, Token } from '@uniswap/sdk-core';
 import { MixedRouteSDK } from './mixedRoute/route';
+export declare function getPathToken(currency: Currency, pool: Pair | V3Pool): Token;
 export interface IRoute<TInput extends Currency, TOutput extends Currency, TPool extends Pair | V3Pool | V4Pool> {
     protocol: Protocol;
     pools: TPool[];
@@ -11,15 +12,21 @@ export interface IRoute<TInput extends Currency, TOutput extends Currency, TPool
     midPrice: Price<TInput, TOutput>;
     input: TInput;
     output: TOutput;
+    pathInput: Currency;
+    pathOutput: Currency;
 }
 export declare class RouteV2<TInput extends Currency, TOutput extends Currency> extends V2RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, Pair> {
     readonly protocol: Protocol;
     readonly pools: Pair[];
+    pathInput: Currency;
+    pathOutput: Currency;
     constructor(v2Route: V2RouteSDK<TInput, TOutput>);
 }
 export declare class RouteV3<TInput extends Currency, TOutput extends Currency> extends V3RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, V3Pool> {
     readonly protocol: Protocol;
     readonly path: Token[];
+    pathInput: Currency;
+    pathOutput: Currency;
     constructor(v3Route: V3RouteSDK<TInput, TOutput>);
 }
 export declare class RouteV4<TInput extends Currency, TOutput extends Currency> extends V4RouteSDK<TInput, TOutput> implements IRoute<TInput, TOutput, V4Pool> {

package/dist/entities/trade.d.ts

@@ -43,6 +43,24 @@ export declare class Trade<TInput extends Currency, TOutput extends Currency, TT
     });
     get inputAmount(): CurrencyAmount<TInput>;
     get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * Returns the sum of all swaps within the trade
+     * @returns
+     * inputAmount: total input amount
+     * inputAmountNative: total amount of native currency required for ETH input paths
+     *  - 0 if inputAmount is native but no native input paths
+     *  - undefined if inputAmount is not native
+     * outputAmount: total output amount
+     * outputAmountNative: total amount of native currency returned from ETH output paths
+     *  - 0 if outputAmount is native but no native output paths
+     *  - undefined if outputAmount is not native
+     */
+    get amounts(): {
+        inputAmount: CurrencyAmount<TInput>;
+        inputAmountNative: CurrencyAmount<TInput> | undefined;
+        outputAmount: CurrencyAmount<TOutput>;
+        outputAmountNative: CurrencyAmount<TOutput> | undefined;
+    };
     private _executionPrice;
     /**
      * The price expressed in terms of output amount/input amount.

package/dist/index.d.ts

@@ -12,4 +12,3 @@ export * from './utils/encodeMixedRouteToPath';
 export * from './utils/TPool';
 export * from './utils/pathCurrency';
 export * from './utils';
-export * from './utils/isValidTokenPath';

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

@@ -628,22 +628,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.");
 }
 
-function isValidTokenPath(prevPool, currentPool, inputToken) {
-  if (inputToken instanceof sdkCore.Token && currentPool.involvesToken(inputToken)) return true;
-  if (currentPool instanceof v4Sdk.Pool && currentPool.involvesToken(inputToken)) return true;
-  // throw if both v4 pools, native/wrapped tokens not interchangeable in v4
-  if (prevPool instanceof v4Sdk.Pool && currentPool instanceof v4Sdk.Pool) return false;
-  // v2/v3 --> v4 valid if v2/v3 output is the wrapped version of the v4 pool native currency
-  if (currentPool instanceof v4Sdk.Pool) {
-    if (currentPool.token0.wrapped.equals(inputToken) || currentPool.token1.wrapped.equals(inputToken)) return true;
-  }
-  // v4 --> v2/v3 valid if v4 output is the native version of the v2/v3 wrapped token
-  if (prevPool instanceof v4Sdk.Pool) {
-    if (currentPool.involvesToken(inputToken.wrapped)) return true;
-  }
-  return false;
-}
-
 function amountWithPathCurrency(amount, pool) {
   return sdkCore.CurrencyAmount.fromFractionalAmount(getPathCurrency(amount.currency, pool), amount.numerator, amount.denominator);
 }
@@ -679,10 +663,18 @@ var MixedRouteSDK = /*#__PURE__*/function () {
    * @param pools An array of `TPool` objects (pools or pairs), ordered by the route the swap will take
    * @param input The input token
    * @param output The output token
+   * @param retainsFakePool Set to true to filter out a pool that has a fake eth-weth pool
    */
-  function MixedRouteSDK(pools, input, output) {
+  function MixedRouteSDK(pools, input, output, retainFakePools) {
+    if (retainFakePools === void 0) {
+      retainFakePools = false;
+    }
     this._midPrice = null;
+    pools = retainFakePools ? pools : pools.filter(function (pool) {
+      return !(pool instanceof v4Sdk.Pool && pool.tickSpacing === 0);
+    });
     !(pools.length > 0) ?  invariant(false, 'POOLS')  : void 0;
+    // there is a pool mismatched to the path if we do not retain the fake eth-weth pools
     var chainId = pools[0].chainId;
     var allOnSameChain = pools.every(function (pool) {
       return pool.chainId === chainId;
@@ -690,7 +682,11 @@ var MixedRouteSDK = /*#__PURE__*/function () {
     !allOnSameChain ?  invariant(false, 'CHAIN_IDS')  : void 0;
     this.pathInput = getPathCurrency(input, pools[0]);
     this.pathOutput = getPathCurrency(output, pools[pools.length - 1]);
-    !pools[0].involvesToken(this.pathInput) ?  invariant(false, 'INPUT')  : void 0;
+    if (!(pools[0] instanceof v4Sdk.Pool)) {
+      !pools[0].involvesToken(this.pathInput) ?  invariant(false, 'INPUT')  : void 0;
+    } else {
+      !pools[0].v4InvolvesToken(this.pathInput) ?  invariant(false, 'INPUT')  : void 0;
+    }
     var lastPool = pools[pools.length - 1];
     if (lastPool instanceof v4Sdk.Pool) {
       !(lastPool.v4InvolvesToken(output) || lastPool.v4InvolvesToken(output.wrapped)) ?  invariant(false, 'OUTPUT')  : void 0;
@@ -703,11 +699,31 @@ var MixedRouteSDK = /*#__PURE__*/function () {
     var tokenPath = [this.pathInput];
     pools[0].token0.equals(this.pathInput) ? tokenPath.push(pools[0].token1) : tokenPath.push(pools[0].token0);
     for (var i = 1; i < pools.length; i++) {
-      var prevPool = pools[i - 1];
       var pool = pools[i];
       var inputToken = tokenPath[i];
-      var outputToken = pool instanceof v4Sdk.Pool ? pool.token0.equals(inputToken) ? pool.token1 : pool.token0 : pool.token0.wrapped.equals(inputToken.wrapped) ? pool.token1 : pool.token0;
-      !isValidTokenPath(prevPool, pool, inputToken) ?  invariant(false, "PATH")  : void 0;
+      var outputToken = void 0;
+      if (
+      // we hit an edge case if it's a v4 pool and neither of the tokens are in the pool OR it is not a v4 pool but the input currency is eth
+      pool instanceof v4Sdk.Pool && !pool.involvesToken(inputToken) || !(pool instanceof v4Sdk.Pool) && inputToken.isNative) {
+        // We handle the case where the inputToken =/= pool.token0 or pool.token1. There are 2 specific cases.
+        if (inputToken.equals(pool.token0.wrapped)) {
+          // 1) the inputToken is WETH and the current pool has ETH
+          // for example, pools: USDC-WETH, ETH-PEPE, path: USDC, WETH, PEPE
+          // second pool is a v4 pool, the first could be any version
+          outputToken = pool.token1;
+        } else if (inputToken.wrapped.equals(pool.token0) || inputToken.wrapped.equals(pool.token1)) {
+          // 2) the inputToken is ETH and the current pool has WETH
+          // for example, pools: USDC-ETH, WETH-PEPE, path: USDC, ETH, PEPE
+          // first pool is a v4 pool, the second could be any version
+          outputToken = inputToken.wrapped.equals(pool.token0) ? pool.token1 : pool.token0;
+        } else {
+          throw new Error("POOL_MISMATCH pool: " + JSON.stringify(pool) + " inputToken: " + JSON.stringify(inputToken));
+        }
+      } else {
+        // then the input token must equal either token0 or token1
+        !(inputToken.equals(pool.token0) || inputToken.equals(pool.token1)) ?  invariant(false, "PATH pool " + JSON.stringify(pool) + " inputToken " + JSON.stringify(inputToken))  : void 0;
+        outputToken = inputToken.equals(pool.token0) ? pool.token1 : pool.token0;
+      }
       tokenPath.push(outputToken);
     }
     this.pools = pools;
@@ -1285,6 +1301,17 @@ var MixedRouteTrade = /*#__PURE__*/function () {
   Protocol["MIXED"] = "MIXED";
 })(exports.Protocol || (exports.Protocol = {}));
 
+// Helper function to get the pathInput and pathOutput for a V2 / V3 route
+// currency could be native so we check against the wrapped version as they don't support native ETH in path
+function getPathToken(currency, pool) {
+  if (pool.token0.wrapped.equals(currency.wrapped)) {
+    return pool.token0;
+  } else if (pool.token1.wrapped.equals(currency.wrapped)) {
+    return pool.token1;
+  } else {
+    throw new Error("Expected token " + currency.symbol + " to be either " + pool.token0.symbol + " or " + pool.token1.symbol);
+  }
+}
 // V2 route wrapper
 var RouteV2 = /*#__PURE__*/function (_V2RouteSDK) {
   _inheritsLoose(RouteV2, _V2RouteSDK);
@@ -1293,6 +1320,8 @@ var RouteV2 = /*#__PURE__*/function (_V2RouteSDK) {
     _this = _V2RouteSDK.call(this, v2Route.pairs, v2Route.input, v2Route.output) || this;
     _this.protocol = exports.Protocol.V2;
     _this.pools = _this.pairs;
+    _this.pathInput = getPathToken(v2Route.input, _this.pairs[0]);
+    _this.pathOutput = getPathToken(v2Route.output, _this.pairs[_this.pairs.length - 1]);
     return _this;
   }
   return RouteV2;
@@ -1305,6 +1334,8 @@ var RouteV3 = /*#__PURE__*/function (_V3RouteSDK) {
     _this2 = _V3RouteSDK.call(this, v3Route.pools, v3Route.input, v3Route.output) || this;
     _this2.protocol = exports.Protocol.V3;
     _this2.path = v3Route.tokenPath;
+    _this2.pathInput = getPathToken(v3Route.input, _this2.pools[0]);
+    _this2.pathOutput = getPathToken(v3Route.output, _this2.pools[_this2.pools.length - 1]);
     return _this2;
   }
   return RouteV3;
@@ -1696,13 +1727,13 @@ var Trade = /*#__PURE__*/function () {
       if (this._inputAmount) {
         return this._inputAmount;
       }
-      var inputCurrency = this.swaps[0].inputAmount.currency;
+      var inputAmountCurrency = this.swaps[0].inputAmount.currency;
       var totalInputFromRoutes = this.swaps.map(function (_ref5) {
-        var inputAmount = _ref5.inputAmount;
-        return inputAmount;
+        var routeInputAmount = _ref5.inputAmount;
+        return routeInputAmount;
       }).reduce(function (total, cur) {
         return total.add(cur);
-      }, sdkCore.CurrencyAmount.fromRawAmount(inputCurrency, 0));
+      }, sdkCore.CurrencyAmount.fromRawAmount(inputAmountCurrency, 0));
       this._inputAmount = totalInputFromRoutes;
       return this._inputAmount;
     }
@@ -1714,14 +1745,50 @@ var Trade = /*#__PURE__*/function () {
       }
       var outputCurrency = this.swaps[0].outputAmount.currency;
       var totalOutputFromRoutes = this.swaps.map(function (_ref6) {
-        var outputAmount = _ref6.outputAmount;
-        return outputAmount;
+        var routeOutputAmount = _ref6.outputAmount;
+        return routeOutputAmount;
       }).reduce(function (total, cur) {
         return total.add(cur);
       }, sdkCore.CurrencyAmount.fromRawAmount(outputCurrency, 0));
       this._outputAmount = totalOutputFromRoutes;
       return this._outputAmount;
     }
+    /**
+     * Returns the sum of all swaps within the trade
+     * @returns
+     * inputAmount: total input amount
+     * inputAmountNative: total amount of native currency required for ETH input paths
+     *  - 0 if inputAmount is native but no native input paths
+     *  - undefined if inputAmount is not native
+     * outputAmount: total output amount
+     * outputAmountNative: total amount of native currency returned from ETH output paths
+     *  - 0 if outputAmount is native but no native output paths
+     *  - undefined if outputAmount is not native
+     */
+  }, {
+    key: "amounts",
+    get: function get() {
+      var _this$swaps$find, _this$swaps$find2;
+      // Find native currencies for reduce below
+      var inputNativeCurrency = (_this$swaps$find = this.swaps.find(function (_ref7) {
+        var inputAmount = _ref7.inputAmount;
+        return inputAmount.currency.isNative;
+      })) == null ? void 0 : _this$swaps$find.inputAmount.currency;
+      var outputNativeCurrency = (_this$swaps$find2 = this.swaps.find(function (_ref8) {
+        var outputAmount = _ref8.outputAmount;
+        return outputAmount.currency.isNative;
+      })) == null ? void 0 : _this$swaps$find2.outputAmount.currency;
+      return {
+        inputAmount: this.inputAmount,
+        inputAmountNative: inputNativeCurrency ? this.swaps.reduce(function (total, swap) {
+          return swap.route.pathInput.isNative ? total.add(swap.inputAmount) : total;
+        }, sdkCore.CurrencyAmount.fromRawAmount(inputNativeCurrency, 0)) : undefined,
+        outputAmount: this.outputAmount,
+        outputAmountNative: outputNativeCurrency ? this.swaps.reduce(function (total, swap) {
+          return swap.route.pathOutput.isNative ? total.add(swap.outputAmount) : total;
+        }, sdkCore.CurrencyAmount.fromRawAmount(outputNativeCurrency, 0)) : undefined
+      };
+    }
     /**
      * The price expressed in terms of output amount/input amount.
      */
@@ -2368,8 +2435,8 @@ exports.amountWithPathCurrency = amountWithPathCurrency;
 exports.encodeMixedRouteToPath = encodeMixedRouteToPath;
 exports.getOutputOfPools = getOutputOfPools;
 exports.getPathCurrency = getPathCurrency;
+exports.getPathToken = getPathToken;
 exports.isMint = isMint;
-exports.isValidTokenPath = isValidTokenPath;
 exports.partitionMixedRouteByProtocol = partitionMixedRouteByProtocol;
 exports.tradeComparator = tradeComparator;
 //# sourceMappingURL=router-sdk.cjs.development.js.map