@uniswap/universal-router-sdk 2.0.2 → 2.0.4-beta.2

package/README.md

@@ -92,66 +92,8 @@ const unwrapWETH = new UnwrapWETH(amountWETH, chainId, optionalPermit2Params)
 const { calldata, value } = SwapRouter.swapCallParameters([unwrapWETH, seaportTrades, looksRareTrades])
 ```
 
-### Trading stETH
-To trade stETH as an input token, you can make sure the router automatically wraps stETH to wstETH before trading across a wstETH route. Make sure to specify the router is the payer of the swap (since it's in custody of wSTETH after wrapping)
-
-If this is an exactOut trade, we'll need to wrap the maximumAmountIn of steth, and therefore should add an unwrap command at the end of the transaction to account for any leftover steth that didn't get traded. `amountMinimum` can be set to 0 in this scenario for the unwrapSteth commmand.
-```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 {
-  UniswapTrade,
-  WrapSTETH
-} from "@uniswap/universal-router-sdk";
-
-// EXACT INPUT
-// including optional permit2 parameter will transfer STETH amount using permit2
-const wrapSTETH = new WrapSTETH(inputSTETH, chainId, WrapSTETHPermitData?, wrapAmountOtherThanContractBalance?)
-const uniswapWstethTrade = new UniswapTrade(
-  new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_INPUT }),
-  { slippageTolerance, payerIsRouter: true }
-)
-const { calldata, value } = SwapRouter.swapCallParameters([wrapSTETH, uniswapWstethTrade])
-
-// EXACT OUTPUT
-const wrapSTETH = new WrapSTETH(maximumInputSTETH, chainId, WrapSTETHPermitData?, wrapAmountOtherThanContractBalance?)
-const uniswapWstethTrade = new UniswapTrade(
-  new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_OUTPUT }),
-  { slippageTolerance, payerIsRouter: true }
-)
-const unwrapSTETH = new UnwrapSTETH(recipient, amountMinimum = 0, chainId)
-
-const { calldata, value } = SwapRouter.swapCallParameters([wrapSTETH, uniswapWstethTrade, unwrapSTETH])
-
-```
-
-To recieve stETH as an output token, you can make sure the router automatically unwraps wstETH to stETH before returning to the swapper
-```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,
-  UnwrapSTETH
-} from "@uniswap/universal-router-sdk";
-
-// return trade to the router instead of the recipient using the ROUTER_AS_RECIPIENT constant so that the router may custody tokens to unwrap
-const uniswapWstethTrade = new UniswapTrade(
-  new RouterTrade({ v2Routes, v3Routes, mixedRoutes, tradeType: TradeType.EXACT_INPUT }),
-  { slippageTolerance, recipient: ROUTER_AS_RECIPIENT}
-)
-const unwrapSTETH = new UnwrapSTETH(recipient, amountMinimum, chainId)
-
-const { calldata, value } = SwapRouter.swapCallParameters([uniswapWstethTrade, unwrapSTETH])
-```
-
-
 ## Running this package
-Make sure you are running `node v16`
+Make sure you are running `node v18`
 Install dependencies and run typescript unit tests
 ```bash
 yarn install
@@ -160,7 +102,6 @@ yarn test:hardhat
 
 Run forge integration tests
 ```bash
-yarn symlink # must install git submodules
 forge install
 yarn test:forge
 ```

package/dist/entities/Command.d.ts

@@ -5,9 +5,7 @@ export declare type TradeConfig = {
 export declare enum RouterTradeType {
     UniswapTrade = "UniswapTrade",
     NFTTrade = "NFTTrade",
-    UnwrapWETH = "UnwrapWETH",
-    WrapSTETH = "WrapSTETH",
-    UnwrapSTETH = "UnwrapSTETH"
+    UnwrapWETH = "UnwrapWETH"
 }
 export interface Command {
     tradeType: RouterTradeType;

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

@@ -8,5 +8,3 @@ export * from './uniswap';
 export * from './sudoswap';
 export * from './x2y2';
 export * from './unwrapWETH';
-export * from './wrapSTETH';
-export * from './unwrapSTETH';

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

@@ -9,14 +9,17 @@ export declare type FlatFeeOptions = {
     recipient: string;
 };
 export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
+    useRouterBalance?: boolean;
     inputTokenPermit?: Permit2Permit;
-    payerIsRouter?: boolean;
     flatFee?: FlatFeeOptions;
+    safeMode?: boolean;
 };
 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/test/utils/uniswapData.d.ts

@@ -0,0 +1,23 @@
+import { MixedRouteTrade, Trade as RouterTrade } from '@uniswap/router-sdk';
+import { Trade as V2Trade, Pair } from '@uniswap/v2-sdk';
+import { Trade as V3Trade, Pool, FeeAmount } from '@uniswap/v3-sdk';
+import { SwapOptions } from '../../src';
+import { TradeType, Ether, Token, Currency } from '@uniswap/sdk-core';
+export declare const ETHER: Ether;
+export declare const WETH: Token;
+export declare const DAI: Token;
+export declare const USDC: Token;
+export declare const FEE_AMOUNT = FeeAmount.MEDIUM;
+declare type UniswapPools = {
+    WETH_USDC_V2: Pair;
+    USDC_DAI_V2: Pair;
+    WETH_USDC_V3: Pool;
+    WETH_USDC_V3_LOW_FEE: Pool;
+    USDC_DAI_V3: Pool;
+};
+export declare function getUniswapPools(forkBlock?: number): Promise<UniswapPools>;
+export declare function getPair(tokenA: Token, tokenB: Token, blockNumber: number): Promise<Pair>;
+export declare function getPool(tokenA: Token, tokenB: Token, feeAmount: FeeAmount, blockNumber: number): Promise<Pool>;
+export declare function swapOptions(options: Partial<SwapOptions>): SwapOptions;
+export declare function buildTrade(trades: (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[]): RouterTrade<Currency, Currency, TradeType>;
+export {};

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

@@ -16,6 +16,37 @@ var sdkCore = require('@uniswap/sdk-core');
 require('jsbi');
 require('bignumber.js');
 
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
+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, _toPropertyKey(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++) {
@@ -78,8 +109,6 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
   RouterTradeType["UniswapTrade"] = "UniswapTrade";
   RouterTradeType["NFTTrade"] = "NFTTrade";
   RouterTradeType["UnwrapWETH"] = "UnwrapWETH";
-  RouterTradeType["WrapSTETH"] = "WrapSTETH";
-  RouterTradeType["UnwrapSTETH"] = "UnwrapSTETH";
 })(exports.RouterTradeType || (exports.RouterTradeType = {}));
 
 var NFTTrade = function NFTTrade(market, orders) {
@@ -140,8 +169,6 @@ var _ABI_DEFINITION;
   CommandType[CommandType["SEAPORT_V1_4"] = 32] = "SEAPORT_V1_4";
   CommandType[CommandType["EXECUTE_SUB_PLAN"] = 33] = "EXECUTE_SUB_PLAN";
   CommandType[CommandType["APPROVE_ERC20"] = 34] = "APPROVE_ERC20";
-  CommandType[CommandType["WRAP_STETH"] = 35] = "WRAP_STETH";
-  CommandType[CommandType["UNWRAP_STETH"] = 36] = "UNWRAP_STETH";
 })(exports.CommandType || (exports.CommandType = {}));
 var ALLOW_REVERT_FLAG = 0x80;
 var REVERTIBLE_COMMANDS = /*#__PURE__*/new Set([exports.CommandType.SEAPORT_V1_5, exports.CommandType.SEAPORT_V1_4, exports.CommandType.NFTX, exports.CommandType.LOOKS_RARE_V2, exports.CommandType.X2Y2_721, exports.CommandType.X2Y2_1155, exports.CommandType.FOUNDATION, exports.CommandType.SUDOSWAP, exports.CommandType.NFT20, exports.CommandType.EXECUTE_SUB_PLAN, exports.CommandType.CRYPTOPUNKS, exports.CommandType.ELEMENT_MARKET]);
@@ -149,7 +176,7 @@ var PERMIT_STRUCT = '((address token,uint160 amount,uint48 expiration,uint48 non
 var PERMIT_BATCH_STRUCT = '((address token,uint160 amount,uint48 expiration,uint48 nonce)[] details,address spender,uint256 sigDeadline)';
 var PERMIT2_TRANSFER_FROM_STRUCT = '(address from,address to,uint160 amount,address token)';
 var PERMIT2_TRANSFER_FROM_BATCH_STRUCT = PERMIT2_TRANSFER_FROM_STRUCT + '[]';
-var ABI_DEFINITION = (_ABI_DEFINITION = {}, _ABI_DEFINITION[exports.CommandType.EXECUTE_SUB_PLAN] = ['bytes', 'bytes[]'], _ABI_DEFINITION[exports.CommandType.PERMIT2_PERMIT] = [PERMIT_STRUCT, 'bytes'], _ABI_DEFINITION[exports.CommandType.PERMIT2_PERMIT_BATCH] = [PERMIT_BATCH_STRUCT, 'bytes'], _ABI_DEFINITION[exports.CommandType.PERMIT2_TRANSFER_FROM] = ['address', 'address', 'uint160'], _ABI_DEFINITION[exports.CommandType.PERMIT2_TRANSFER_FROM_BATCH] = [PERMIT2_TRANSFER_FROM_BATCH_STRUCT], _ABI_DEFINITION[exports.CommandType.V3_SWAP_EXACT_IN] = ['address', 'uint256', 'uint256', 'bytes', 'bool'], _ABI_DEFINITION[exports.CommandType.V3_SWAP_EXACT_OUT] = ['address', 'uint256', 'uint256', 'bytes', 'bool'], _ABI_DEFINITION[exports.CommandType.V2_SWAP_EXACT_IN] = ['address', 'uint256', 'uint256', 'address[]', 'bool'], _ABI_DEFINITION[exports.CommandType.V2_SWAP_EXACT_OUT] = ['address', 'uint256', 'uint256', 'address[]', 'bool'], _ABI_DEFINITION[exports.CommandType.WRAP_ETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.UNWRAP_WETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP_ERC721] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP_ERC1155] = ['address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.TRANSFER] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.PAY_PORTION] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.BALANCE_CHECK_ERC20] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.OWNER_CHECK_721] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.OWNER_CHECK_1155] = ['address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.APPROVE_ERC20] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.WRAP_STETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.UNWRAP_STETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SEAPORT_V1_5] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.SEAPORT_V1_4] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.NFTX] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.LOOKS_RARE_V2] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.X2Y2_721] = ['uint256', 'bytes', 'address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.X2Y2_1155] = ['uint256', 'bytes', 'address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.FOUNDATION] = ['uint256', 'bytes', 'address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SUDOSWAP] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.NFT20] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.CRYPTOPUNKS] = ['uint256', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.ELEMENT_MARKET] = ['uint256', 'bytes'], _ABI_DEFINITION);
+var ABI_DEFINITION = (_ABI_DEFINITION = {}, _ABI_DEFINITION[exports.CommandType.EXECUTE_SUB_PLAN] = ['bytes', 'bytes[]'], _ABI_DEFINITION[exports.CommandType.PERMIT2_PERMIT] = [PERMIT_STRUCT, 'bytes'], _ABI_DEFINITION[exports.CommandType.PERMIT2_PERMIT_BATCH] = [PERMIT_BATCH_STRUCT, 'bytes'], _ABI_DEFINITION[exports.CommandType.PERMIT2_TRANSFER_FROM] = ['address', 'address', 'uint160'], _ABI_DEFINITION[exports.CommandType.PERMIT2_TRANSFER_FROM_BATCH] = [PERMIT2_TRANSFER_FROM_BATCH_STRUCT], _ABI_DEFINITION[exports.CommandType.V3_SWAP_EXACT_IN] = ['address', 'uint256', 'uint256', 'bytes', 'bool'], _ABI_DEFINITION[exports.CommandType.V3_SWAP_EXACT_OUT] = ['address', 'uint256', 'uint256', 'bytes', 'bool'], _ABI_DEFINITION[exports.CommandType.V2_SWAP_EXACT_IN] = ['address', 'uint256', 'uint256', 'address[]', 'bool'], _ABI_DEFINITION[exports.CommandType.V2_SWAP_EXACT_OUT] = ['address', 'uint256', 'uint256', 'address[]', 'bool'], _ABI_DEFINITION[exports.CommandType.WRAP_ETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.UNWRAP_WETH] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP_ERC721] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SWEEP_ERC1155] = ['address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.TRANSFER] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.PAY_PORTION] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.BALANCE_CHECK_ERC20] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.OWNER_CHECK_721] = ['address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.OWNER_CHECK_1155] = ['address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.APPROVE_ERC20] = ['address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SEAPORT_V1_5] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.SEAPORT_V1_4] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.NFTX] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.LOOKS_RARE_V2] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.X2Y2_721] = ['uint256', 'bytes', 'address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.X2Y2_1155] = ['uint256', 'bytes', 'address', 'address', 'uint256', 'uint256'], _ABI_DEFINITION[exports.CommandType.FOUNDATION] = ['uint256', 'bytes', 'address', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.SUDOSWAP] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.NFT20] = ['uint256', 'bytes'], _ABI_DEFINITION[exports.CommandType.CRYPTOPUNKS] = ['uint256', 'address', 'uint256'], _ABI_DEFINITION[exports.CommandType.ELEMENT_MARKET] = ['uint256', 'bytes'], _ABI_DEFINITION);
 var RoutePlanner = /*#__PURE__*/function () {
   function RoutePlanner() {
     this.commands = '0x';
@@ -184,97 +211,71 @@ function createCommand(type, parameters) {
 }
 
 var _CHAIN_CONFIGS;
-var NOT_SUPPORTED_ON_CHAIN = '0x0000000000000000000000000000000000000000';
+var WETH_NOT_SUPPORTED_ON_CHAIN = '0x0000000000000000000000000000000000000000';
 var CHAIN_CONFIGS = (_CHAIN_CONFIGS = {}, _CHAIN_CONFIGS[1] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
-  steth: '0xae7ab96520de3a18e5e111b5eaab095312d7fe84',
-  wsteth: '0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0',
   creationBlock: 17143817
 }, _CHAIN_CONFIGS[5] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6',
-  steth: '0x1643E812aE58766192Cf7D2Cf9567dF2C37e9B7F',
-  wsteth: '0x6320cD32aA674d2898A68ec82e869385Fc5f7E2f',
   creationBlock: 8940568
 }, _CHAIN_CONFIGS[11155111] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 3543575
 }, _CHAIN_CONFIGS[137] = {
-  router: '0x643770E279d5D0733F21d6DC03A8efbABf3255B4',
+  router: '0xec7BE89e9d109e7e3Fec59c222CF297125FEFda2',
   weth: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 46866777
+  creationBlock: 52210153
 }, _CHAIN_CONFIGS[80001] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 35176052
 }, _CHAIN_CONFIGS[10] = {
-  router: '0xeC8B0F7Ffe3ae75d7FfAb09429e3675bb63503e4',
+  router: '0xCb1355ff08Ab38bBCE60111F1bb2B784bE25D7e8',
   weth: '0x4200000000000000000000000000000000000006',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 108825869
+  creationBlock: 114702266
 }, _CHAIN_CONFIGS[420] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0x4200000000000000000000000000000000000006',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 8887728
 }, _CHAIN_CONFIGS[42161] = {
-  router: '0xeC8B0F7Ffe3ae75d7FfAb09429e3675bb63503e4',
+  router: '0x5E325eDA8064b456f4781070C0738d849c824258',
   weth: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 125861718
+  creationBlock: 169472836
 }, _CHAIN_CONFIGS[421613] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0xe39Ab88f8A4777030A534146A9Ca3B52bd5D43A3',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 18815277
 }, _CHAIN_CONFIGS[42220] = {
-  router: '0x88a3ED7F21A3fCF6adb86b6F878C5B7a02D20e9b',
-  weth: NOT_SUPPORTED_ON_CHAIN,
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 21116361
+  router: '0x643770e279d5d0733f21d6dc03a8efbabf3255b4',
+  weth: WETH_NOT_SUPPORTED_ON_CHAIN,
+  creationBlock: 21407637
 }, _CHAIN_CONFIGS[44787] = {
   router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
-  weth: NOT_SUPPORTED_ON_CHAIN,
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
+  weth: WETH_NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 17566658
 }, _CHAIN_CONFIGS[56] = {
-  router: '0xeC8B0F7Ffe3ae75d7FfAb09429e3675bb63503e4',
+  router: '0x4Dae2f939ACf50408e13d58534Ff8c2776d45265',
   weth: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 31254967
+  creationBlock: 35160263
 }, _CHAIN_CONFIGS[43114] = {
-  router: '0x82635AF6146972cD6601161c4472ffe97237D292',
+  router: '0x4Dae2f939ACf50408e13d58534Ff8c2776d45265',
   weth: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 34491144
+  creationBlock: 40237257
 }, _CHAIN_CONFIGS[84531] = {
   router: '0xd0872d928672ae2ff74bdb2f5130ac12229cafaf',
   weth: '0x4200000000000000000000000000000000000006',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
   creationBlock: 6915289
 }, _CHAIN_CONFIGS[8453] = {
-  router: '0xeC8B0F7Ffe3ae75d7FfAb09429e3675bb63503e4',
+  router: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
   weth: '0x4200000000000000000000000000000000000006',
-  steth: NOT_SUPPORTED_ON_CHAIN,
-  wsteth: NOT_SUPPORTED_ON_CHAIN,
-  creationBlock: 3229053
+  creationBlock: 9107268
+}, _CHAIN_CONFIGS[81457] = {
+  router: '0x643770E279d5D0733F21d6DC03A8efbABf3255B4',
+  weth: '0x4300000000000000000000000000000000000004',
+  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);
@@ -286,17 +287,13 @@ var UNIVERSAL_ROUTER_CREATION_BLOCK = function UNIVERSAL_ROUTER_CREATION_BLOCK(c
 };
 var WETH_ADDRESS = function WETH_ADDRESS(chainId) {
   if (!(chainId in CHAIN_CONFIGS)) throw new Error("Universal Router not deployed on chain " + chainId);
-  if (CHAIN_CONFIGS[chainId].weth == NOT_SUPPORTED_ON_CHAIN) throw new Error("Chain " + chainId + " does not have WETH");
+  if (CHAIN_CONFIGS[chainId].weth == WETH_NOT_SUPPORTED_ON_CHAIN) throw new Error("Chain " + chainId + " does not have WETH");
   return CHAIN_CONFIGS[chainId].weth;
 };
-var STETH_ADDRESS = function STETH_ADDRESS(chainId) {
-  if (!(chainId in CHAIN_CONFIGS)) throw new Error("Universal Router not deployed on chain " + chainId);
-  if (CHAIN_CONFIGS[chainId].steth == NOT_SUPPORTED_ON_CHAIN) throw new Error("Chain " + chainId + " does not have STETH support");
-  return CHAIN_CONFIGS[chainId].steth;
-};
 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';
@@ -316,17 +313,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 = !this.options.payerIsRouter;
     // 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;
@@ -336,19 +331,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');
@@ -388,12 +382,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
@@ -623,18 +624,11 @@ var SwapRouter = /*#__PURE__*/function () {
           allowRevert: false
         });
         currentNativeValueInRouter = currentNativeValueInRouter.add(UnwrapWETH.amount);
-        /**
-         * is (Un)WrapSTETH
-         */
-      } else if (trade.tradeType == exports.RouterTradeType.WrapSTETH || trade.tradeType == exports.RouterTradeType.UnwrapSTETH) {
-        trade.encode(planner, {
-          allowRevert: false
-        });
         /**
          * else
          */
       } else {
-        throw 'trade must be of instance: UniswapTrade, NFTTrade, UnwrapWETH, WrapSTETH';
+        throw 'trade must be of instance: UniswapTrade or NFTTrade';
       }
     }
     // TODO: matches current logic for now, but should eventually only sweep for multiple NFT trades
@@ -8198,7 +8192,7 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
     var considerationRecipients = [];
     for (var i in protocolDatas) {
       var protocolData = protocolDatas[i];
-      var _loop = function _loop(j) {
+      var _loop = function _loop() {
         var item = protocolData.parameters.consideration[j];
         if (considerationRecipients.findIndex(function (x) {
           return x === item.recipient;
@@ -8221,7 +8215,7 @@ var SeaportTrade = /*#__PURE__*/function (_NFTTrade) {
         }
       };
       for (var j in protocolData.parameters.consideration) {
-        _loop(j);
+        _loop();
       }
     }
     return considerationFulfillments;
@@ -10587,45 +10581,122 @@ var UnwrapWETH = /*#__PURE__*/function () {
   return UnwrapWETH;
 }();
 
-var WrapSTETH = /*#__PURE__*/function () {
-  function WrapSTETH(amount, chainId, permit2, wrapAmount) {
-    this.tradeType = exports.RouterTradeType.WrapSTETH;
-    this.stethAddress = STETH_ADDRESS(chainId);
-    this.amount = amount;
-    this.wrapAmount = wrapAmount != null ? wrapAmount : CONTRACT_BALANCE;
-    if (!!permit2) {
-      !(permit2.details.token.toLowerCase() === this.stethAddress.toLowerCase()) ?  invariant(false, "must be permitting STETH address: " + this.stethAddress)  : void 0;
-      !(permit2.details.amount >= amount) ?  invariant(false, "Did not permit enough STETH for unwrapSTETH transaction")  : void 0;
-      this.permit2Data = permit2;
-    }
-  }
-  var _proto = WrapSTETH.prototype;
-  _proto.encode = function encode(planner, _) {
-    encodeInputTokenOptions(planner, {
-      permit2Permit: this.permit2Data,
-      permit2TransferFrom: {
-        token: this.stethAddress,
-        amount: this.amount.toString()
+(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
     });
-    planner.addCommand(exports.CommandType.WRAP_STETH, [ROUTER_AS_RECIPIENT, this.wrapAmount]);
   };
-  return WrapSTETH;
-}();
-
-var UnwrapSTETH = /*#__PURE__*/function () {
-  function UnwrapSTETH(recipient, amountMinimum, chainId) {
-    this.tradeType = exports.RouterTradeType.UnwrapSTETH;
-    this.recipient = recipient;
-    this.amountMinimum = amountMinimum;
-    !(STETH_ADDRESS(chainId) != NOT_SUPPORTED_ON_CHAIN) ?  invariant(false, "STETH not supported on chain " + chainId)  : void 0;
-  }
-  var _proto = UnwrapSTETH.prototype;
-  _proto.encode = function encode(planner, _) {
-    planner.addCommand(exports.CommandType.UNWRAP_STETH, [this.recipient, this.amountMinimum]);
+  RouterTradeAdapter.toCurrency = function toCurrency(isNative, token) {
+    if (isNative) {
+      return sdkCore.Ether.onChain(token.chainId);
+    }
+    return this.toToken(token);
   };
-  return UnwrapSTETH;
+  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;
@@ -10636,15 +10707,15 @@ 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;
 exports.UNIVERSAL_ROUTER_ADDRESS = UNIVERSAL_ROUTER_ADDRESS;
 exports.UNIVERSAL_ROUTER_CREATION_BLOCK = UNIVERSAL_ROUTER_CREATION_BLOCK;
 exports.UniswapTrade = UniswapTrade;
-exports.UnwrapSTETH = UnwrapSTETH;
 exports.UnwrapWETH = UnwrapWETH;
 exports.WETH_ADDRESS = WETH_ADDRESS;
-exports.WrapSTETH = WrapSTETH;
 exports.X2Y2Trade = X2Y2Trade;
+exports.isNativeCurrency = isNativeCurrency;
 //# sourceMappingURL=universal-router-sdk.cjs.development.js.map