@uniswap/universal-router-sdk 1.3.3 → 1.3.4

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

@@ -1,7 +1,7 @@
 import invariant from 'tiny-invariant';
 import { abi as abi$7 } from '@uniswap/universal-router/artifacts/contracts/UniversalRouter.sol/UniversalRouter.json';
 import { Interface } from '@ethersproject/abi';
-import { BigNumber } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import JSBI from 'jsbi';
 import { defaultAbiCoder } from 'ethers/lib/utils';
 import { Trade, Pair } from '@uniswap/v2-sdk';
@@ -53,6 +53,13 @@ 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.");
 }
 
+var RouterTradeType;
+(function (RouterTradeType) {
+  RouterTradeType["UniswapTrade"] = "UniswapTrade";
+  RouterTradeType["NFTTrade"] = "NFTTrade";
+  RouterTradeType["UnwrapWETH"] = "UnwrapWETH";
+})(RouterTradeType || (RouterTradeType = {}));
+
 var _ABI_DEFINITION;
 /**
  * CommandTypes
@@ -126,7 +133,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
@@ -153,11 +160,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__*/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 Percent( /*#__PURE__*/JSBI.BigInt(50), /*#__PURE__*/JSBI.BigInt(100));
 // Wrapper for uniswap router-sdk trade entity to encode swaps for Universal Router
@@ -166,6 +200,7 @@ var UniswapTrade = /*#__PURE__*/function () {
   function UniswapTrade(trade, options) {
     this.trade = trade;
     this.options = options;
+    this.tradeType = RouterTradeType.UniswapTrade;
   }
   var _proto = UniswapTrade.prototype;
   _proto.encode = function encode(planner, _config) {
@@ -173,11 +208,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
@@ -226,11 +261,11 @@ function addV2Swap(planner, _ref, tradeType, options, payerIsUser, routerMustCus
   if (tradeType == 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 == 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]);
   }
@@ -248,9 +283,9 @@ function addV3Swap(planner, _ref2, tradeType, options, payerIsUser, routerMustCu
   });
   var path = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
   if (tradeType == 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 == 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
@@ -258,7 +293,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 Pool) {
@@ -305,7 +340,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]);
     }
@@ -317,37 +352,117 @@ function riskOfPartialFill(trade) {
 }
 
 function encodePermit(planner, permit) {
-  planner.addCommand(CommandType.PERMIT, [permit, permit.signature]);
+  // sanitizes signature to cover edge cases like malformed EIP-2098 sigs and v used as recovery id
+  var sanitizedSignature = ethers.utils.joinSignature(ethers.utils.splitSignature(permit.signature));
+  planner.addCommand(CommandType.PERMIT, [permit, sanitizedSignature]);
 }
 
 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 = BigNumber.from(0);
+    var transactionValue = BigNumber.from(0);
+    for (var _iterator = _createForOfIteratorHelperLoose(trades), _step; !(_step = _iterator()).done;) {
+      var trade = _step.value;
+      /**
+       * is NFTTrade
+       */
+      if (trade.tradeType == 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 = BigNumber.from(0);
+        } else {
+          currentNativeValueInRouter = currentNativeValueInRouter.sub(tradePrice);
+        }
+        /**
+         * is Uniswap Trade
+         */
+      } else if (trade.tradeType == 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) ? process.env.NODE_ENV !== "production" ? invariant(false, 'NATIVE_INPUT_PERMIT') : invariant(false) : void 0;
+        if (!!swapOptions.inputTokenPermit) {
+          encodePermit(planner, swapOptions.inputTokenPermit);
+        }
+        if (inputIsNative) {
+          transactionValue = transactionValue.add(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(BigNumber.from(uniswapTrade.trade.minimumAmountOut(swapOptions.slippageTolerance).quotient.toString()));
+        }
+        uniswapTrade.encode(planner, {
+          allowRevert: false
+        });
+        /**
+         * is UnwrapWETH
+         */
+      } else if (trade.tradeType == 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 ? process.env.NODE_ENV !== "production" ? invariant(false, 'SENDER_REQUIRED') : invariant(false) : void 0;
+    if (config === void 0) {
+      config = {};
+    }
     var planner = new RoutePlanner();
     var totalPrice = 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;
@@ -380,7 +495,7 @@ var SwapRouter = /*#__PURE__*/function () {
     var calldata = SwapRouter.INTERFACE.encodeFunctionData(functionSignature, parameters);
     return {
       calldata: calldata,
-      value: nativeCurrencyValue.toString()
+      value: nativeCurrencyValue.toHexString()
     };
   };
   return SwapRouter;
@@ -388,6 +503,7 @@ var SwapRouter = /*#__PURE__*/function () {
 SwapRouter.INTERFACE = /*#__PURE__*/new Interface(abi$7);
 
 var NFTTrade = function NFTTrade(market, orders) {
+  this.tradeType = RouterTradeType.NFTTrade;
   !(orders.length > 0) ? process.env.NODE_ENV !== "production" ? invariant(false, 'no buy Items') : invariant(false) : void 0;
   this.market = market;
   this.orders = orders;
@@ -9276,5 +9392,26 @@ var X2Y2Trade = /*#__PURE__*/function (_NFTTrade) {
 }(NFTTrade);
 X2Y2Trade.INTERFACE = /*#__PURE__*/new Interface(abi$6);
 
-export { CryptopunkTrade, FoundationTrade, LooksRareTrade, Market, NFT20Trade, NFTTrade, NFTXTrade, PERMIT2_ADDRESS, SeaportTrade, SudoswapTrade, SwapRouter, TokenType, UNIVERSAL_ROUTER_ADDRESS, UniswapTrade, X2Y2Trade };
+var UnwrapWETH = /*#__PURE__*/function () {
+  function UnwrapWETH(amount, chainId, permit2) {
+    this.tradeType = RouterTradeType.UnwrapWETH;
+    this.wethAddress = WETH_ADDRESS(chainId);
+    this.routerAddress = UNIVERSAL_ROUTER_ADDRESS(chainId);
+    this.amount = amount;
+    if (!!permit2) {
+      !(permit2.details.token === this.wethAddress) ? process.env.NODE_ENV !== "production" ? invariant(false, "must be permitting WETH address: " + this.wethAddress) : invariant(false) : void 0;
+      !(permit2.details.amount >= amount) ? process.env.NODE_ENV !== "production" ? invariant(false, "Did not permit enough WETH for unwrapWETH transaction") : invariant(false) : void 0;
+      this.permit2Data = permit2;
+    }
+  }
+  var _proto = UnwrapWETH.prototype;
+  _proto.encode = function encode(planner, _) {
+    if (!!this.permit2Data) encodePermit(planner, this.permit2Data);
+    planner.addCommand(CommandType.PERMIT2_TRANSFER_FROM, [this.wethAddress, this.routerAddress, this.amount]);
+    planner.addCommand(CommandType.UNWRAP_WETH, [ROUTER_AS_RECIPIENT, this.amount]);
+  };
+  return UnwrapWETH;
+}();
+
+export { CryptopunkTrade, FoundationTrade, LooksRareTrade, Market, NFT20Trade, NFTTrade, NFTXTrade, PERMIT2_ADDRESS, ROUTER_AS_RECIPIENT, RouterTradeType, SeaportTrade, SudoswapTrade, SwapRouter, TokenType, UNIVERSAL_ROUTER_ADDRESS, UniswapTrade, UnwrapWETH, WETH_ADDRESS, X2Y2Trade };
 //# sourceMappingURL=universal-router-sdk.esm.js.map