@uniswap/universal-router-sdk 1.8.2 → 1.9.0

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

@@ -9,6 +9,7 @@ export declare type FlatFeeOptions = {
     recipient: string;
 };
 export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
+    useRouterBalance?: boolean;
     inputTokenPermit?: Permit2Permit;
     flatFee?: FlatFeeOptions;
     safeMode?: boolean;
@@ -17,6 +18,8 @@ export declare class UniswapTrade implements Command {
     trade: RouterTrade<Currency, Currency, TradeType>;
     options: SwapOptions;
     readonly tradeType: RouterTradeType;
+    readonly payerIsUser: boolean;
     constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
+    get inputRequiresWrap(): boolean;
     encode(planner: RoutePlanner, _config: TradeConfig): void;
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { SwapRouter } from './swapRouter';
 export * from './entities';
+export * from './utils/routerTradeAdapter';
 export { RoutePlanner, CommandType } from './utils/routerCommands';
 export { UNIVERSAL_ROUTER_ADDRESS, UNIVERSAL_ROUTER_CREATION_BLOCK, PERMIT2_ADDRESS, ROUTER_AS_RECIPIENT, WETH_ADDRESS, } from './utils/constants';

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

@@ -16,6 +16,23 @@ var sdkCore = require('@uniswap/sdk-core');
 require('jsbi');
 require('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++) {
@@ -262,6 +279,7 @@ var WETH_ADDRESS = function WETH_ADDRESS(chainId) {
 var PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
 var CONTRACT_BALANCE = /*#__PURE__*/ethers.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';
@@ -281,17 +299,15 @@ var UniswapTrade = /*#__PURE__*/function () {
     this.options = options;
     this.tradeType = exports.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(exports.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;
@@ -301,19 +317,18 @@ var UniswapTrade = /*#__PURE__*/function () {
     //      in that the reversion probability is lower
     var performAggregatedSlippageCheck = this.trade.tradeType === sdkCore.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 routerSdk.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 routerSdk.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 routerSdk.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');
@@ -353,13 +368,19 @@ var UniswapTrade = /*#__PURE__*/function () {
         planner.addCommand(exports.CommandType.SWEEP, [this.trade.outputAmount.currency.wrapped.address, this.options.recipient, minimumAmountOut]);
       }
     }
-    if (inputIsNative && (this.trade.tradeType === sdkCore.TradeType.EXACT_OUTPUT || riskOfPartialFill(this.trade))) {
+    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]);
     }
     if (this.options.safeMode) planner.addCommand(exports.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
@@ -10546,6 +10567,123 @@ var UnwrapWETH = /*#__PURE__*/function () {
   return UnwrapWETH;
 }();
 
+(function (PoolType) {
+  PoolType["V2Pool"] = "v2-pool";
+  PoolType["V3Pool"] = "v3-pool";
+})(exports.PoolType || (exports.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 = sdkCore.CurrencyAmount.fromRawAmount(parsedCurrencyIn, rawAmountIn);
+      var outputAmount = sdkCore.CurrencyAmount.fromRawAmount(parsedCurrencyOut, rawAmountOut);
+      var isOnlyV2 = RouterTradeAdapter.isVersionedRoute(exports.PoolType.V2Pool, subRoute);
+      var isOnlyV3 = RouterTradeAdapter.isVersionedRoute(exports.PoolType.V3Pool, subRoute);
+      return {
+        routev3: isOnlyV3 ? new v3Sdk.Route(subRoute.map(RouterTradeAdapter.toPool), parsedCurrencyIn, parsedCurrencyOut) : null,
+        routev2: isOnlyV2 ? new v2Sdk.Route(subRoute.map(RouterTradeAdapter.toPair), parsedCurrencyIn, parsedCurrencyOut) : null,
+        mixedRoute: !isOnlyV3 && !isOnlyV2 ? new routerSdk.MixedRouteSDK(subRoute.map(RouterTradeAdapter.toPoolOrPair), parsedCurrencyIn, parsedCurrencyOut) : null,
+        inputAmount: inputAmount,
+        outputAmount: outputAmount
+      };
+    });
+    return new routerSdk.Trade({
+      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 sdkCore.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 sdkCore.Token(chainId, address, parseInt(decimals.toString()), symbol, /* name */undefined, false, buyFeeBps ? ethers.BigNumber.from(buyFeeBps) : undefined, sellFeeBps ? ethers.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 v3Sdk.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 === exports.PoolType.V3Pool ? RouterTradeAdapter.toPool(pool) : RouterTradeAdapter.toPair(pool);
+};
+RouterTradeAdapter.toPair = function (_ref2) {
+  var reserve0 = _ref2.reserve0,
+    reserve1 = _ref2.reserve1;
+  return new v2Sdk.Pair(sdkCore.CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve0.token), reserve0.quotient), sdkCore.CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve1.token), reserve1.quotient));
+};
+
 exports.CryptopunkTrade = CryptopunkTrade;
 exports.FoundationTrade = FoundationTrade;
 exports.LooksRareV2Trade = LooksRareV2Trade;
@@ -10555,6 +10693,7 @@ exports.NFTXTrade = NFTXTrade;
 exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
 exports.ROUTER_AS_RECIPIENT = ROUTER_AS_RECIPIENT;
 exports.RoutePlanner = RoutePlanner;
+exports.RouterTradeAdapter = RouterTradeAdapter;
 exports.SeaportTrade = SeaportTrade;
 exports.SudoswapTrade = SudoswapTrade;
 exports.SwapRouter = SwapRouter;
@@ -10564,4 +10703,5 @@ exports.UniswapTrade = UniswapTrade;
 exports.UnwrapWETH = UnwrapWETH;
 exports.WETH_ADDRESS = WETH_ADDRESS;
 exports.X2Y2Trade = X2Y2Trade;
+exports.isNativeCurrency = isNativeCurrency;
 //# sourceMappingURL=universal-router-sdk.cjs.development.js.map