@uniswap/universal-router-sdk 1.8.1 → 1.9.0

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

@@ -3,13 +3,30 @@ import { abi as abi$7 } from '@uniswap/universal-router/artifacts/contracts/Univ
 import { Interface } from '@ethersproject/abi';
 import { BigNumber, ethers } from 'ethers';
 import { defaultAbiCoder } from 'ethers/lib/utils';
-import { Trade, Pair } from '@uniswap/v2-sdk';
-import { toHex, Trade as Trade$1, encodeRouteToPath, Pool } from '@uniswap/v3-sdk';
-import { Protocol, MixedRouteTrade, partitionMixedRouteByProtocol, getOutputOfPools, MixedRouteSDK, MixedRoute, encodeMixedRouteToPath } from '@uniswap/router-sdk';
-import { TradeType, Percent } from '@uniswap/sdk-core';
+import { Trade, Pair, Route as Route$1 } from '@uniswap/v2-sdk';
+import { toHex, Trade as Trade$1, encodeRouteToPath, Pool, Route } from '@uniswap/v3-sdk';
+import { Protocol, MixedRouteTrade, partitionMixedRouteByProtocol, getOutputOfPools, MixedRouteSDK, MixedRoute, encodeMixedRouteToPath, Trade as Trade$2 } from '@uniswap/router-sdk';
+import { TradeType, Percent, CurrencyAmount, Ether, Token } from '@uniswap/sdk-core';
 import 'jsbi';
 import 'bignumber.js';
 
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -245,9 +262,9 @@ var CHAIN_CONFIGS = (_CHAIN_CONFIGS = {}, _CHAIN_CONFIGS[1] = {
   weth: '0x4200000000000000000000000000000000000006',
   creationBlock: 9107268
 }, _CHAIN_CONFIGS[81457] = {
-  router: '0xe463635f6e73C1E595554C3ae216472D0fb929a9',
+  router: '0x643770E279d5D0733F21d6DC03A8efbABf3255B4',
   weth: '0x4300000000000000000000000000000000000004',
-  creationBlock: 401447
+  creationBlock: 1116444
 }, _CHAIN_CONFIGS);
 var UNIVERSAL_ROUTER_ADDRESS = function UNIVERSAL_ROUTER_ADDRESS(chainId) {
   if (!(chainId in CHAIN_CONFIGS)) throw new Error("Universal Router not deployed on chain " + chainId);
@@ -265,6 +282,7 @@ var WETH_ADDRESS = function WETH_ADDRESS(chainId) {
 var PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
 var CONTRACT_BALANCE = /*#__PURE__*/BigNumber.from(2).pow(255);
 var ETH_ADDRESS = '0x0000000000000000000000000000000000000000';
+var E_ETH_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
 var ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 var SENDER_AS_RECIPIENT = '0x0000000000000000000000000000000000000001';
 var ROUTER_AS_RECIPIENT = '0x0000000000000000000000000000000000000002';
@@ -284,17 +302,15 @@ var UniswapTrade = /*#__PURE__*/function () {
     this.options = options;
     this.tradeType = RouterTradeType.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;
   }
   var _proto = UniswapTrade.prototype;
   _proto.encode = function encode(planner, _config) {
     var _this$options$recipie;
-    var payerIsUser = true;
     // If the input currency is the native currency, we need to wrap it with the router as the recipient
-    if (this.trade.inputAmount.currency.isNative) {
+    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()]);
-      // since WETH is now owned by the router, the router pays for inputs
-      payerIsUser = false;
     }
     // 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;
@@ -304,19 +320,18 @@ var UniswapTrade = /*#__PURE__*/function () {
     //      in that the reversion probability is lower
     var performAggregatedSlippageCheck = this.trade.tradeType === TradeType.EXACT_INPUT && this.trade.routes.length > 2;
     var outputIsNative = this.trade.outputAmount.currency.isNative;
-    var inputIsNative = this.trade.inputAmount.currency.isNative;
     var routerMustCustody = performAggregatedSlippageCheck || outputIsNative || hasFeeOption(this.options);
     for (var _iterator = _createForOfIteratorHelperLoose(this.trade.swaps), _step; !(_step = _iterator()).done;) {
       var swap = _step.value;
       switch (swap.route.protocol) {
         case Protocol.V2:
-          addV2Swap(planner, swap, this.trade.tradeType, this.options, payerIsUser, routerMustCustody);
+          addV2Swap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         case Protocol.V3:
-          addV3Swap(planner, swap, this.trade.tradeType, this.options, payerIsUser, routerMustCustody);
+          addV3Swap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         case Protocol.MIXED:
-          addMixedSwap(planner, swap, this.trade.tradeType, this.options, payerIsUser, routerMustCustody);
+          addMixedSwap(planner, swap, this.trade.tradeType, this.options, this.payerIsUser, routerMustCustody);
           break;
         default:
           throw new Error('UNSUPPORTED_TRADE_PROTOCOL');
@@ -356,13 +371,19 @@ var UniswapTrade = /*#__PURE__*/function () {
         planner.addCommand(CommandType.SWEEP, [this.trade.outputAmount.currency.wrapped.address, this.options.recipient, minimumAmountOut]);
       }
     }
-    if (inputIsNative && (this.trade.tradeType === TradeType.EXACT_OUTPUT || riskOfPartialFill(this.trade))) {
+    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]);
     }
     if (this.options.safeMode) planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, this.options.recipient, 0]);
   };
+  _createClass(UniswapTrade, [{
+    key: "inputRequiresWrap",
+    get: function get() {
+      return this.trade.inputAmount.currency.isNative;
+    }
+  }]);
   return UniswapTrade;
 }();
 // encode a uniswap v2 swap
@@ -10549,5 +10570,123 @@ var UnwrapWETH = /*#__PURE__*/function () {
   return UnwrapWETH;
 }();
 
-export { CommandType, CryptopunkTrade, FoundationTrade, LooksRareV2Trade, Market, NFT20Trade, NFTTrade, NFTXTrade, PERMIT2_ADDRESS, ROUTER_AS_RECIPIENT, RoutePlanner, RouterTradeType, SeaportTrade, SudoswapTrade, SwapRouter, TokenType, UNIVERSAL_ROUTER_ADDRESS, UNIVERSAL_ROUTER_CREATION_BLOCK, UniswapTrade, UnwrapWETH, WETH_ADDRESS, X2Y2Trade };
+var PoolType;
+(function (PoolType) {
+  PoolType["V2Pool"] = "v2-pool";
+  PoolType["V3Pool"] = "v3-pool";
+})(PoolType || (PoolType = {}));
+var isNativeCurrency = function isNativeCurrency(address) {
+  return address.toLowerCase() === ETH_ADDRESS.toLowerCase() || address.toLowerCase() === E_ETH_ADDRESS.toLowerCase();
+};
+// Helper class to convert routing-specific quote entities to RouterTrade entities
+// the returned RouterTrade can then be used to build the UniswapTrade entity in this package
+var RouterTradeAdapter = /*#__PURE__*/function () {
+  function RouterTradeAdapter() {}
+  // Generate a RouterTrade using fields from a classic quote response
+  RouterTradeAdapter.fromClassicQuote = function fromClassicQuote(quote) {
+    var route = quote.route,
+      tokenIn = quote.tokenIn,
+      tokenOut = quote.tokenOut;
+    if (!route) throw new Error('Expected route to be present');
+    if (!route.length) throw new Error('Expected there to be at least one route');
+    if (route.some(function (r) {
+      return !r.length;
+    })) throw new Error('Expected all routes to have at least one pool');
+    var firstRoute = route[0];
+    var tokenInData = firstRoute[0].tokenIn;
+    var tokenOutData = firstRoute[firstRoute.length - 1].tokenOut;
+    if (!tokenInData || !tokenOutData) throw new Error('Expected both tokenIn and tokenOut to be present');
+    if (tokenInData.chainId !== tokenOutData.chainId) throw new Error('Expected tokenIn and tokenOut to be have same chainId');
+    var parsedCurrencyIn = RouterTradeAdapter.toCurrency(isNativeCurrency(tokenIn), tokenInData);
+    var parsedCurrencyOut = RouterTradeAdapter.toCurrency(isNativeCurrency(tokenOut), tokenOutData);
+    var typedRoutes = route.map(function (subRoute) {
+      var rawAmountIn = subRoute[0].amountIn;
+      var rawAmountOut = subRoute[subRoute.length - 1].amountOut;
+      if (!rawAmountIn || !rawAmountOut) {
+        throw new Error('Expected both raw amountIn and raw amountOut to be present');
+      }
+      var inputAmount = CurrencyAmount.fromRawAmount(parsedCurrencyIn, rawAmountIn);
+      var outputAmount = CurrencyAmount.fromRawAmount(parsedCurrencyOut, rawAmountOut);
+      var isOnlyV2 = RouterTradeAdapter.isVersionedRoute(PoolType.V2Pool, subRoute);
+      var isOnlyV3 = RouterTradeAdapter.isVersionedRoute(PoolType.V3Pool, subRoute);
+      return {
+        routev3: isOnlyV3 ? new Route(subRoute.map(RouterTradeAdapter.toPool), parsedCurrencyIn, parsedCurrencyOut) : null,
+        routev2: isOnlyV2 ? new Route$1(subRoute.map(RouterTradeAdapter.toPair), parsedCurrencyIn, parsedCurrencyOut) : null,
+        mixedRoute: !isOnlyV3 && !isOnlyV2 ? new MixedRouteSDK(subRoute.map(RouterTradeAdapter.toPoolOrPair), parsedCurrencyIn, parsedCurrencyOut) : null,
+        inputAmount: inputAmount,
+        outputAmount: outputAmount
+      };
+    });
+    return new Trade$2({
+      v2Routes: typedRoutes.filter(function (route) {
+        return route.routev2;
+      }).map(function (route) {
+        return {
+          routev2: route.routev2,
+          inputAmount: route.inputAmount,
+          outputAmount: route.outputAmount
+        };
+      }),
+      v3Routes: typedRoutes.filter(function (route) {
+        return route.routev3;
+      }).map(function (route) {
+        return {
+          routev3: route.routev3,
+          inputAmount: route.inputAmount,
+          outputAmount: route.outputAmount
+        };
+      }),
+      mixedRoutes: typedRoutes.filter(function (route) {
+        return route.mixedRoute;
+      }).map(function (route) {
+        return {
+          mixedRoute: route.mixedRoute,
+          inputAmount: route.inputAmount,
+          outputAmount: route.outputAmount
+        };
+      }),
+      tradeType: quote.tradeType
+    });
+  };
+  RouterTradeAdapter.toCurrency = function toCurrency(isNative, token) {
+    if (isNative) {
+      return Ether.onChain(token.chainId);
+    }
+    return this.toToken(token);
+  };
+  RouterTradeAdapter.toToken = function toToken(token) {
+    var chainId = token.chainId,
+      address = token.address,
+      decimals = token.decimals,
+      symbol = token.symbol,
+      buyFeeBps = token.buyFeeBps,
+      sellFeeBps = token.sellFeeBps;
+    return new Token(chainId, address, parseInt(decimals.toString()), symbol, /* name */undefined, false, buyFeeBps ? BigNumber.from(buyFeeBps) : undefined, sellFeeBps ? BigNumber.from(sellFeeBps) : undefined);
+  };
+  RouterTradeAdapter.toPool = function toPool(_ref) {
+    var fee = _ref.fee,
+      sqrtRatioX96 = _ref.sqrtRatioX96,
+      liquidity = _ref.liquidity,
+      tickCurrent = _ref.tickCurrent,
+      tokenIn = _ref.tokenIn,
+      tokenOut = _ref.tokenOut;
+    return new Pool(RouterTradeAdapter.toToken(tokenIn), RouterTradeAdapter.toToken(tokenOut), parseInt(fee), sqrtRatioX96, liquidity, parseInt(tickCurrent));
+  };
+  RouterTradeAdapter.isVersionedRoute = function isVersionedRoute(type, route) {
+    return route.every(function (pool) {
+      return pool.type === type;
+    });
+  };
+  return RouterTradeAdapter;
+}();
+RouterTradeAdapter.toPoolOrPair = function (pool) {
+  return pool.type === PoolType.V3Pool ? RouterTradeAdapter.toPool(pool) : RouterTradeAdapter.toPair(pool);
+};
+RouterTradeAdapter.toPair = function (_ref2) {
+  var reserve0 = _ref2.reserve0,
+    reserve1 = _ref2.reserve1;
+  return new Pair(CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve0.token), reserve0.quotient), CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve1.token), reserve1.quotient));
+};
+
+export { CommandType, CryptopunkTrade, FoundationTrade, LooksRareV2Trade, Market, NFT20Trade, NFTTrade, NFTXTrade, PERMIT2_ADDRESS, PoolType, ROUTER_AS_RECIPIENT, RoutePlanner, RouterTradeAdapter, RouterTradeType, SeaportTrade, SudoswapTrade, SwapRouter, TokenType, UNIVERSAL_ROUTER_ADDRESS, UNIVERSAL_ROUTER_CREATION_BLOCK, UniswapTrade, UnwrapWETH, WETH_ADDRESS, X2Y2Trade, isNativeCurrency };
 //# sourceMappingURL=universal-router-sdk.esm.js.map