@uniswap/universal-router-sdk 1.2.3 → 1.3.1

package/README.md

@@ -5,6 +5,7 @@ This SDK facilitates interactions with the contracts in [Universal Router](https
 Install latest version of universal-router-sdk. Then import the corresponding Trade class and Data object for each protocol you'd like to interact with.
 
 ### Trading NFTs
+warning: `swapNFTCallParameters()` to be deprecated in favor of `swapCallParameters()`
 ```typescript
 import {
   LooksRareTrade,
@@ -20,10 +21,11 @@ const seaportTrades = new SeaportTrade([seaportData1])
 
 // Use the raw calldata and value returned to call into Universal Swap Router contracts
 // Trades will happen in the order that they are handed in
-const { calldata, value } = SwapRouter.swapNFTCallParameters([looksRareTrades, seaportTrades], { sender: sender.address })
+const { calldata, value } = SwapRouter.swapCallParameters([looksRareTrades, seaportTrades])
 ```
 
 ### Trading ERC20s on Uniswap
+warning: `swapERC20CallParameters()` to be deprecated in favor of `swapCallParameters()`
 ```typescript
 import { TradeType } from '@uniswap/sdk-core'
 import { Trade as V2TradeSDK } from '@uniswap/v2-sdk'
@@ -31,11 +33,44 @@ import { Trade as V3TradeSDK } from '@uniswap/v3-sdk'
 import { MixedRouteTrade, MixedRouteSDK, Trade as RouterTrade } from '@uniswap/router-sdk'
 
 const options = { slippageTolerance, recipient }
-const routerTrade = new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_INPUT })
+const routerTrade = new UniswapTrade(
+  new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_INPUT },
+  options
+)
 // Use the raw calldata and value returned to call into Universal Swap Router contracts
-const { calldata, value } = SwapRouter.swapERC20CallParameters(buildTrade([trade]), options)
+const { calldata, value } = SwapRouter.swapCallParameters(routerTrade)
 ```
 
+### Using Uniswap for ERC20 NFT Trades
+Send ETH to the router by trading an ERC20 for ETH with a Uniswap Trade and encoding the swap recipient as `ROUTER_AS_RECIPIENT` in the trade. Then subsequently list the NFT trades to use the ETH output to buy NFTs. Trades happen in the order they are listed.
+
+Use `trade_type: TradeType.EXACT_OUTPUT` to cover the entire NFT price, alternatively the transaction will send supplemental ETH to fulfill the entire price if the swap does not cover it in full. Keep in mind that `TradeType.EXACT_INPUT` trades are subject to slippage on output, and ETH will be sent to cover potential slippage and any remaining ETH will be returned to sender.
+```typescript
+import { TradeType } from '@uniswap/sdk-core'
+import { Trade as V2TradeSDK } from '@uniswap/v2-sdk'
+import { Trade as V3TradeSDK } from '@uniswap/v3-sdk'
+import { MixedRouteTrade, MixedRouteSDK, Trade as RouterTrade } from '@uniswap/router-sdk'
+import {
+  ROUTER_AS_RECIPIENT,
+  UniswapTrade,
+  LooksRareTrade,
+  LooksRareData,
+  SeaportTrade,
+  SeaportData
+} from "@uniswap/universal-router-sdk";
+
+const looksRareTrades = new LooksRareTrade([looksrareData1, looksrareData2])
+const seaportTrades = new SeaportTrade([seaportData1])
+// WARNING: never send funds to ROUTER_AS_RECIPIENT unless it is ETH that will be used in NFT trades, otherwise funds are lost.
+const uniswapTrade = new UniswapTrade(
+  new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_OUTPUT }),
+  { slippageTolerance, recipient:  ROUTER_AS_RECIPIENT}
+)
+// Use the raw calldata and value returned to call into Universal Swap Router contracts
+const { calldata, value } = SwapRouter.swapCallParameters([uniswapTrade, seaportTrades, looksRareTrades])
+```
+
+
 ## Running this package
 Make sure you are running `node v16`
 Install dependencies and run typescript unit tests

package/dist/entities/Command.d.ts

@@ -2,6 +2,11 @@ import { RoutePlanner } from '../utils/routerCommands';
 export declare type TradeConfig = {
     allowRevert: boolean;
 };
+export declare enum RouterTradeType {
+    UniswapTrade = "UniswapTrade",
+    NFTTrade = "NFTTrade"
+}
 export interface Command {
+    tradeType: RouterTradeType;
     encode(planner: RoutePlanner, config: TradeConfig): void;
 }

package/dist/entities/NFTTrade.d.ts

@@ -1,22 +1,23 @@
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 import { SeaportData } from './protocols/seaport';
 import { FoundationData } from './protocols/foundation';
 import { NFTXData } from './protocols/nftx';
 import { NFT20Data } from './protocols/nft20';
 import { RoutePlanner } from '../utils/routerCommands';
-import { Command, TradeConfig } from './Command';
+import { Command, RouterTradeType, TradeConfig } from './Command';
 import { LooksRareData } from './protocols/looksRare';
 import { SudoswapData } from './protocols/sudoswap';
 import { CryptopunkData } from './protocols/cryptopunk';
 import { X2Y2Data } from './protocols/x2y2';
 export declare type SupportedProtocolsData = SeaportData | FoundationData | NFTXData | LooksRareData | X2Y2Data | CryptopunkData | NFT20Data | SudoswapData;
 export declare abstract class NFTTrade<T> implements Command {
+    readonly tradeType: RouterTradeType;
     readonly orders: T[];
     readonly market: Market;
     constructor(market: Market, orders: T[]);
     abstract encode(planner: RoutePlanner, config: TradeConfig): void;
     abstract getBuyItems(): BuyItem[];
-    abstract getTotalPrice(): BigNumberish;
+    abstract getTotalPrice(): BigNumber;
 }
 export declare type BuyItem = {
     tokenAddress: string;

package/dist/entities/index.d.ts

@@ -1,2 +1,3 @@
 export * from './protocols';
 export * from './NFTTrade';
+export * from './Command';

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

@@ -1,7 +1,7 @@
 import { TradeConfig } from '../Command';
 import { NFTTrade, BuyItem } from '../NFTTrade';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 export declare type CryptopunkData = {
     tokenId: BigNumberish;
     recipient: string;
@@ -12,5 +12,5 @@ export declare class CryptopunkTrade extends NFTTrade<CryptopunkData> {
     constructor(orders: CryptopunkData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }

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

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi';
 import { BuyItem, NFTTrade } from '../NFTTrade';
 import { TradeConfig } from '../Command';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 export declare type FoundationData = {
     recipient: string;
     tokenAddress: string;
@@ -15,5 +15,5 @@ export declare class FoundationTrade extends NFTTrade<FoundationData> {
     constructor(orders: FoundationData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }

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

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi';
 import { BuyItem, NFTTrade, TokenType } from '../NFTTrade';
 import { TradeConfig } from '../Command';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 export declare type MakerOrder = {
     collection: string;
     tokenId: BigNumberish;
@@ -40,5 +40,5 @@ export declare class LooksRareTrade extends NFTTrade<LooksRareData> {
     constructor(orders: LooksRareData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }

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

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi';
 import { TradeConfig } from '../Command';
 import { NFTTrade, BuyItem } from '../NFTTrade';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 export declare type NFT20Data = {
     tokenAddress: string;
     tokenIds: BigNumberish[];
@@ -17,5 +17,5 @@ export declare class NFT20Trade extends NFTTrade<NFT20Data> {
     constructor(orders: NFT20Data[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }

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

@@ -16,5 +16,5 @@ export declare class NFTXTrade extends NFTTrade<NFTXData> {
     constructor(orders: NFTXData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }

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

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi';
 import { BuyItem, NFTTrade } from '../NFTTrade';
 import { TradeConfig } from '../Command';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 declare type PairSwap = {
     swapInfo: {
         pair: string;
@@ -22,6 +22,6 @@ export declare class SudoswapTrade extends NFTTrade<SudoswapData> {
     constructor(orders: SudoswapData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }
 export {};

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

@@ -2,13 +2,14 @@ import { RoutePlanner } from '../../utils/routerCommands';
 import { Trade as RouterTrade, SwapOptions as RouterSwapOptions } from '@uniswap/router-sdk';
 import { Permit2Permit } from '../../utils/permit2';
 import { Currency, TradeType } from '@uniswap/sdk-core';
-import { Command, TradeConfig } from '../Command';
+import { Command, RouterTradeType, TradeConfig } from '../Command';
 export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
     inputTokenPermit?: Permit2Permit;
 };
 export declare class UniswapTrade implements Command {
     trade: RouterTrade<Currency, Currency, TradeType>;
     options: SwapOptions;
+    readonly tradeType: RouterTradeType;
     constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
     encode(planner: RoutePlanner, _config: TradeConfig): void;
 }

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

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi';
 import { BuyItem, NFTTrade, TokenType } from '../NFTTrade';
 import { TradeConfig } from '../Command';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { BigNumberish } from 'ethers';
+import { BigNumber, BigNumberish } from 'ethers';
 declare type X2Y2PartialData = {
     signedInput: string;
     recipient: string;
@@ -23,6 +23,6 @@ export declare class X2Y2Trade extends NFTTrade<X2Y2Data> {
     constructor(orders: X2Y2Data[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalPrice(): BigNumberish;
+    getTotalPrice(): BigNumber;
 }
 export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { SwapRouter } from './swapRouter';
 export * from './entities';
-export { UNIVERSAL_ROUTER_ADDRESS, PERMIT2_ADDRESS } from './utils/constants';
+export { UNIVERSAL_ROUTER_ADDRESS, PERMIT2_ADDRESS, ROUTER_AS_RECIPIENT } from './utils/constants';

package/dist/swapRouter.d.ts

@@ -3,20 +3,25 @@ import { BigNumberish } from 'ethers';
 import { MethodParameters } from '@uniswap/v3-sdk';
 import { Trade as RouterTrade } from '@uniswap/router-sdk';
 import { Currency, TradeType } from '@uniswap/sdk-core';
+import { Command } from './entities/Command';
 import { NFTTrade, SupportedProtocolsData } from './entities/NFTTrade';
 import { SwapOptions } from './entities/protocols/uniswap';
 export declare type SwapRouterConfig = {
     sender?: string;
     deadline?: BigNumberish;
 };
+declare type SupportedNFTTrade = NFTTrade<SupportedProtocolsData>;
 export declare abstract class SwapRouter {
     static INTERFACE: Interface;
+    static swapCallParameters(trades: Command[] | Command, config?: SwapRouterConfig): MethodParameters;
     /**
+     * @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
      */
-    static swapNFTCallParameters(trades: NFTTrade<SupportedProtocolsData>[], config: SwapRouterConfig): MethodParameters;
+    static swapNFTCallParameters(trades: SupportedNFTTrade[], config?: SwapRouterConfig): MethodParameters;
     /**
+     * @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
@@ -30,3 +35,4 @@ export declare abstract class SwapRouter {
      */
     private static encodePlan;
 }
+export {};

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

@@ -8,12 +8,12 @@ var invariant = _interopDefault(require('tiny-invariant'));
 var UniversalRouter_json = require('@uniswap/universal-router/artifacts/contracts/UniversalRouter.sol/UniversalRouter.json');
 var abi$7 = require('@ethersproject/abi');
 var ethers = require('ethers');
-var sdkCore = require('@uniswap/sdk-core');
 var JSBI = _interopDefault(require('jsbi'));
 var utils = require('ethers/lib/utils');
 var v2Sdk = require('@uniswap/v2-sdk');
 var v3Sdk = require('@uniswap/v3-sdk');
 var routerSdk = require('@uniswap/router-sdk');
+var sdkCore = require('@uniswap/sdk-core');
 
 function _inheritsLoose(subClass, superClass) {
   subClass.prototype = Object.create(superClass.prototype);
@@ -59,6 +59,11 @@ 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";
+})(exports.RouterTradeType || (exports.RouterTradeType = {}));
+
 var _ABI_DEFINITION;
 /**
  * CommandTypes
@@ -162,8 +167,8 @@ var UNIVERSAL_ROUTER_ADDRESS = function UNIVERSAL_ROUTER_ADDRESS(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 +177,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 +185,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 +238,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 +260,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 +270,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 +317,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,37 +334,99 @@ 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 UniswapTrade
+      } 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
+        });
+      } 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;
     !!(inputCurrency.isNative && !!options.inputTokenPermit) ?  invariant(false, 'NATIVE_INPUT_PERMIT')  : void 0;
-    if (options.inputTokenPermit && inputCurrency instanceof sdkCore.Token) {
+    if (options.inputTokenPermit) {
       encodePermit(planner, options.inputTokenPermit);
     }
     var nativeCurrencyValue = inputCurrency.isNative ? ethers.BigNumber.from(trade.trade.maximumAmountIn(options.slippageTolerance).quotient.toString()) : ethers.BigNumber.from(0);
@@ -386,7 +454,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 +462,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,6 +9356,7 @@ 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;