@uniswap/universal-router-sdk 1.3.0 → 1.3.2

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

@@ -59,6 +59,12 @@ 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 (RouterTradeType) {
+  RouterTradeType["UniswapTrade"] = "UniswapTrade";
+  RouterTradeType["NFTTrade"] = "NFTTrade";
+  RouterTradeType["UnwrapWETH"] = "UnwrapWETH";
+})(exports.RouterTradeType || (exports.RouterTradeType = {}));
+
 var _ABI_DEFINITION;
 /**
  * CommandTypes
@@ -132,7 +138,7 @@ function createCommand(type, parameters) {
 var UNIVERSAL_ROUTER_ADDRESS = function UNIVERSAL_ROUTER_ADDRESS(chainId) {
   switch (chainId) {
     case 1:
-      //mainnet
+      // mainnet
       return '0xEf1c6E67703c7BD7107eed8303Fbe6EC2554BF6B';
     case 5:
       // goerli
@@ -159,11 +165,38 @@ var UNIVERSAL_ROUTER_ADDRESS = function UNIVERSAL_ROUTER_ADDRESS(chainId) {
       throw new Error("Universal Router not deployed on chain " + chainId);
   }
 };
+var WETH_ADDRESS = function WETH_ADDRESS(chainId) {
+  switch (chainId) {
+    case 1:
+      //mainnet
+      return '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+    case 5:
+      // goerli
+      return '0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6';
+    case 137:
+      // polygon
+      return '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270';
+    case 10:
+      // optimism
+      return '0x4200000000000000000000000000000000000006';
+    case 42161:
+      // arbitrum
+      return '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1';
+    case 420:
+      // optimism goerli
+      return '0x4200000000000000000000000000000000000006';
+    case 421613:
+      // arbitrum goerli
+      return '0xe39Ab88f8A4777030A534146A9Ca3B52bd5D43A3';
+    default:
+      throw new Error("WETH9 or UniversalRouter not deployed on chain " + chainId);
+  }
+};
 var PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
 var CONTRACT_BALANCE = /*#__PURE__*/ethers.BigNumber.from(2).pow(255);
 var ETH_ADDRESS = '0x0000000000000000000000000000000000000000';
-var MSG_SENDER = '0x0000000000000000000000000000000000000001';
-var ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
+var SENDER_AS_RECIPIENT = '0x0000000000000000000000000000000000000001';
+var ROUTER_AS_RECIPIENT = '0x0000000000000000000000000000000000000002';
 
 var REFUND_ETH_PRICE_IMPACT_THRESHOLD = /*#__PURE__*/new sdkCore.Percent( /*#__PURE__*/JSBI.BigInt(50), /*#__PURE__*/JSBI.BigInt(100));
 // Wrapper for uniswap router-sdk trade entity to encode swaps for Universal Router
@@ -172,6 +205,7 @@ var UniswapTrade = /*#__PURE__*/function () {
   function UniswapTrade(trade, options) {
     this.trade = trade;
     this.options = options;
+    this.tradeType = exports.RouterTradeType.UniswapTrade;
   }
   var _proto = UniswapTrade.prototype;
   _proto.encode = function encode(planner, _config) {
@@ -179,11 +213,11 @@ var UniswapTrade = /*#__PURE__*/function () {
     var payerIsUser = true;
     if (this.trade.inputAmount.currency.isNative) {
       // TODO: optimize if only one v2 pool we can directly send this to the pool
-      planner.addCommand(CommandType.WRAP_ETH, [ADDRESS_THIS, this.trade.maximumAmountIn(this.options.slippageTolerance).quotient.toString()]);
+      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;
     }
-    this.options.recipient = (_this$options$recipie = this.options.recipient) != null ? _this$options$recipie : MSG_SENDER;
+    this.options.recipient = (_this$options$recipie = this.options.recipient) != null ? _this$options$recipie : SENDER_AS_RECIPIENT;
     // flag for whether we want to perform slippage check on aggregate output of multiple routes
     //   1. when there are >2 exact input trades. this is only a heuristic,
     //      as it's still more gas-expensive even in this case, but has benefits
@@ -232,11 +266,11 @@ function addV2Swap(planner, _ref, tradeType, options, payerIsUser, routerMustCus
   if (tradeType == sdkCore.TradeType.EXACT_INPUT) {
     planner.addCommand(CommandType.V2_SWAP_EXACT_IN, [
     // if native, we have to unwrap so keep in the router for now
-    routerMustCustody ? ADDRESS_THIS : options.recipient, trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), route.path.map(function (pool) {
+    routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient, trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), route.path.map(function (pool) {
       return pool.address;
     }), payerIsUser]);
   } else if (tradeType == sdkCore.TradeType.EXACT_OUTPUT) {
-    planner.addCommand(CommandType.V2_SWAP_EXACT_OUT, [routerMustCustody ? ADDRESS_THIS : options.recipient, trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), route.path.map(function (pool) {
+    planner.addCommand(CommandType.V2_SWAP_EXACT_OUT, [routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient, trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), route.path.map(function (pool) {
       return pool.address;
     }), payerIsUser]);
   }
@@ -254,9 +288,9 @@ function addV3Swap(planner, _ref2, tradeType, options, payerIsUser, routerMustCu
   });
   var path = v3Sdk.encodeRouteToPath(route, trade.tradeType === sdkCore.TradeType.EXACT_OUTPUT);
   if (tradeType == sdkCore.TradeType.EXACT_INPUT) {
-    planner.addCommand(CommandType.V3_SWAP_EXACT_IN, [routerMustCustody ? ADDRESS_THIS : options.recipient, trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), path, payerIsUser]);
+    planner.addCommand(CommandType.V3_SWAP_EXACT_IN, [routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient, trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), path, payerIsUser]);
   } else if (tradeType == sdkCore.TradeType.EXACT_OUTPUT) {
-    planner.addCommand(CommandType.V3_SWAP_EXACT_OUT, [routerMustCustody ? ADDRESS_THIS : options.recipient, trade.minimumAmountOut(options.slippageTolerance).quotient.toString(), trade.maximumAmountIn(options.slippageTolerance).quotient.toString(), path, payerIsUser]);
+    planner.addCommand(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]);
   }
 }
 // encode a mixed route swap, i.e. including both v2 and v3 pools
@@ -264,7 +298,7 @@ function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMust
   var route = swap.route,
     inputAmount = swap.inputAmount,
     outputAmount = swap.outputAmount;
-  var tradeRecipient = routerMustCustody ? ADDRESS_THIS : options.recipient;
+  var tradeRecipient = routerMustCustody ? ROUTER_AS_RECIPIENT : options.recipient;
   // single hop, so it can be reduced to plain v2 or v3 swap logic
   if (route.pools.length === 1) {
     if (route.pools[0] instanceof v3Sdk.Pool) {
@@ -311,7 +345,7 @@ function addMixedSwap(planner, swap, tradeType, options, payerIsUser, routerMust
       // note: because of the partitioning function we can be sure that the next section is v2
       isLastSectionInRoute(i) ? tradeRecipient : sections[i + 1][0].liquidityToken.address, i == 0 ? amountIn : CONTRACT_BALANCE, !isLastSectionInRoute(i) ? 0 : amountOut, path, payerIsUser && i === 0]);
     } else {
-      planner.addCommand(CommandType.V2_SWAP_EXACT_IN, [isLastSectionInRoute(i) ? tradeRecipient : ADDRESS_THIS, i === 0 ? amountIn : CONTRACT_BALANCE, !isLastSectionInRoute(i) ? 0 : amountOut, newRoute.path.map(function (pool) {
+      planner.addCommand(CommandType.V2_SWAP_EXACT_IN, [isLastSectionInRoute(i) ? tradeRecipient : ROUTER_AS_RECIPIENT, i === 0 ? amountIn : CONTRACT_BALANCE, !isLastSectionInRoute(i) ? 0 : amountOut, newRoute.path.map(function (pool) {
         return pool.address;
       }), payerIsUser && i === 0]);
     }
@@ -328,32 +362,110 @@ function encodePermit(planner, permit) {
 
 var SwapRouter = /*#__PURE__*/function () {
   function SwapRouter() {}
+  SwapRouter.swapCallParameters = function swapCallParameters(trades, config) {
+    if (config === void 0) {
+      config = {};
+    }
+    if (!Array.isArray(trades)) trades = [trades];
+    var nftTrades = trades.filter(function (trade, _, _ref) {
+      return trade.hasOwnProperty('market');
+    });
+    var allowRevert = nftTrades.length == 1 && nftTrades[0].orders.length == 1 ? false : true;
+    var planner = new RoutePlanner();
+    // track value flow to require the right amount of native value
+    var currentNativeValueInRouter = ethers.BigNumber.from(0);
+    var transactionValue = ethers.BigNumber.from(0);
+    for (var _iterator = _createForOfIteratorHelperLoose(trades), _step; !(_step = _iterator()).done;) {
+      var trade = _step.value;
+      /**
+       * is NFTTrade
+       */
+      if (trade.tradeType == exports.RouterTradeType.NFTTrade) {
+        var nftTrade = trade;
+        nftTrade.encode(planner, {
+          allowRevert: allowRevert
+        });
+        var tradePrice = nftTrade.getTotalPrice();
+        // send enough native value to contract for NFT purchase
+        if (currentNativeValueInRouter.lt(tradePrice)) {
+          transactionValue = transactionValue.add(tradePrice.sub(currentNativeValueInRouter));
+          currentNativeValueInRouter = ethers.BigNumber.from(0);
+        } else {
+          currentNativeValueInRouter = currentNativeValueInRouter.sub(tradePrice);
+        }
+        /**
+         * is Uniswap Trade
+         */
+      } else if (trade.tradeType == exports.RouterTradeType.UniswapTrade) {
+        var uniswapTrade = trade;
+        var inputIsNative = uniswapTrade.trade.inputAmount.currency.isNative;
+        var outputIsNative = uniswapTrade.trade.outputAmount.currency.isNative;
+        var swapOptions = uniswapTrade.options;
+        !!(inputIsNative && !!swapOptions.inputTokenPermit) ?  invariant(false, 'NATIVE_INPUT_PERMIT')  : void 0;
+        if (!!swapOptions.inputTokenPermit) {
+          encodePermit(planner, swapOptions.inputTokenPermit);
+        }
+        if (inputIsNative) {
+          transactionValue = transactionValue.add(ethers.BigNumber.from(uniswapTrade.trade.maximumAmountIn(swapOptions.slippageTolerance).quotient.toString()));
+        }
+        // track amount of native currency in the router
+        if (outputIsNative && swapOptions.recipient == ROUTER_AS_RECIPIENT) {
+          currentNativeValueInRouter = currentNativeValueInRouter.add(ethers.BigNumber.from(uniswapTrade.trade.minimumAmountOut(swapOptions.slippageTolerance).quotient.toString()));
+        }
+        uniswapTrade.encode(planner, {
+          allowRevert: false
+        });
+        /**
+         * is UnwrapWETH
+         */
+      } else if (trade.tradeType == exports.RouterTradeType.UnwrapWETH) {
+        var UnwrapWETH = trade;
+        trade.encode(planner, {
+          allowRevert: false
+        });
+        currentNativeValueInRouter = currentNativeValueInRouter.add(UnwrapWETH.amount);
+        /**
+         * else
+         */
+      } else {
+        throw 'trade must be of instance: UniswapTrade or NFTTrade';
+      }
+    }
+    // TODO: matches current logic for now, but should eventually only sweep for multiple NFT trades
+    // or NFT trades with potential slippage (i.e. sudo)
+    if (nftTrades.length > 0) planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, SENDER_AS_RECIPIENT, 0]);
+    return SwapRouter.encodePlan(planner, transactionValue, config);
+  }
   /**
+   * @deprecated in favor of swapCallParameters. Update before next major version 2.0.0
    * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given swap.
    * @param trades to produce call parameters for
-   */
+   */;
   SwapRouter.swapNFTCallParameters = function swapNFTCallParameters(trades, config) {
-    !!!config.sender ?  invariant(false, 'SENDER_REQUIRED')  : void 0;
+    if (config === void 0) {
+      config = {};
+    }
     var planner = new RoutePlanner();
     var totalPrice = ethers.BigNumber.from(0);
     var allowRevert = trades.length == 1 && trades[0].orders.length == 1 ? false : true;
-    for (var _iterator = _createForOfIteratorHelperLoose(trades), _step; !(_step = _iterator()).done;) {
-      var trade = _step.value;
+    for (var _iterator2 = _createForOfIteratorHelperLoose(trades), _step2; !(_step2 = _iterator2()).done;) {
+      var trade = _step2.value;
       trade.encode(planner, {
         allowRevert: allowRevert
       });
       totalPrice = totalPrice.add(trade.getTotalPrice());
     }
-    planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, config.sender, 0]);
+    planner.addCommand(CommandType.SWEEP, [ETH_ADDRESS, SENDER_AS_RECIPIENT, 0]);
     return SwapRouter.encodePlan(planner, totalPrice, config);
   }
   /**
+   * @deprecated in favor of swapCallParameters. Update before next major version 2.0.0
    * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
    * @param trades to produce call parameters for
    * @param options options for the call parameters
    */;
   SwapRouter.swapERC20CallParameters = function swapERC20CallParameters(trades, options) {
-    // TODO: use permit if signature included in options
+    // TODO: use permit if signature included in swapOptions
     var planner = new RoutePlanner();
     var trade = new UniswapTrade(trades, options);
     var inputCurrency = trade.trade.inputAmount.currency;
@@ -386,7 +498,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var calldata = SwapRouter.INTERFACE.encodeFunctionData(functionSignature, parameters);
     return {
       calldata: calldata,
-      value: nativeCurrencyValue.toString()
+      value: nativeCurrencyValue.toHexString()
     };
   };
   return SwapRouter;
@@ -394,6 +506,7 @@ var SwapRouter = /*#__PURE__*/function () {
 SwapRouter.INTERFACE = /*#__PURE__*/new abi$7.Interface(UniversalRouter_json.abi);
 
 var NFTTrade = function NFTTrade(market, orders) {
+  this.tradeType = exports.RouterTradeType.NFTTrade;
   !(orders.length > 0) ?  invariant(false, 'no buy Items')  : void 0;
   this.market = market;
   this.orders = orders;
@@ -9287,10 +9400,12 @@ exports.NFT20Trade = NFT20Trade;
 exports.NFTTrade = NFTTrade;
 exports.NFTXTrade = NFTXTrade;
 exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+exports.ROUTER_AS_RECIPIENT = ROUTER_AS_RECIPIENT;
 exports.SeaportTrade = SeaportTrade;
 exports.SudoswapTrade = SudoswapTrade;
 exports.SwapRouter = SwapRouter;
 exports.UNIVERSAL_ROUTER_ADDRESS = UNIVERSAL_ROUTER_ADDRESS;
 exports.UniswapTrade = UniswapTrade;
+exports.WETH_ADDRESS = WETH_ADDRESS;
 exports.X2Y2Trade = X2Y2Trade;
 //# sourceMappingURL=universal-router-sdk.cjs.development.js.map