@uniswap/universal-router-sdk 1.3.1 → 1.3.2

package/README.md

@@ -70,6 +70,28 @@ const uniswapTrade = new UniswapTrade(
 const { calldata, value } = SwapRouter.swapCallParameters([uniswapTrade, seaportTrades, looksRareTrades])
 ```
 
+### Using WETH for NFT Trades
+The current router purchases all NFTs with ETH, but you can send WETH to the router to be unwrapped for ETH right before the NFT commands. Similar to ERC20 Uniswap Trades for NFTs, supplemental ETH will be sent in the transaction if the WETH amount will not cover the NFT buys. You can also use ERC20s and WETH to cover the transaction by including both commands before the NFT purchase.
+
+```typescript
+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])
+// if no Permit needed, omit the third var of type Permit2Permit
+const unwrapWETH = new UnwrapWETH(amountWETH, chainId, optionalPermit2Params)
+
+// Use the raw calldata and value returned to call into Universal Swap Router contracts
+const { calldata, value } = SwapRouter.swapCallParameters([unwrapWETH, seaportTrades, looksRareTrades])
+```
+
 
 ## Running this package
 Make sure you are running `node v16`

package/dist/entities/Command.d.ts

@@ -4,7 +4,8 @@ export declare type TradeConfig = {
 };
 export declare enum RouterTradeType {
     UniswapTrade = "UniswapTrade",
-    NFTTrade = "NFTTrade"
+    NFTTrade = "NFTTrade",
+    UnwrapWETH = "UnwrapWETH"
 }
 export interface Command {
     tradeType: RouterTradeType;

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

@@ -0,0 +1,13 @@
+import { BigNumberish } from 'ethers';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { Permit2Permit } from '../../utils/permit2';
+import { Command, RouterTradeType, TradeConfig } from '../Command';
+export declare class UnwrapWETH implements Command {
+    readonly tradeType: RouterTradeType;
+    readonly permit2Data: Permit2Permit;
+    readonly wethAddress: string;
+    readonly routerAddress: string;
+    readonly amount: BigNumberish;
+    constructor(amount: BigNumberish, chainId: number, permit2?: Permit2Permit);
+    encode(planner: RoutePlanner, _: TradeConfig): void;
+}

package/dist/index.d.ts

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

package/dist/test/forge/writeInterop.d.ts

@@ -0,0 +1 @@
+export declare function registerFixture(key: string, data: any): void;

package/dist/test/orders/looksRare.d.ts

@@ -0,0 +1,12 @@
+import { MakerOrder, TakerOrder } from '../../src/entities/protocols/looksRare';
+import { BigNumber } from 'ethers';
+export declare type APIOrder = Omit<MakerOrder, 'collection' | 'currency'> & {
+    collectionAddress: string;
+    currencyAddress: string;
+};
+export declare function createLooksRareOrders(apiOrder: APIOrder, taker: string): {
+    makerOrder: MakerOrder;
+    takerOrder: TakerOrder;
+    value: BigNumber;
+};
+export declare const looksRareOrders: APIOrder[];

package/dist/test/orders/seaport.d.ts

@@ -0,0 +1,4 @@
+import { SeaportData } from '../../src/entities/protocols/seaport';
+import { BigNumber } from 'ethers';
+export declare const seaportData2Covens: SeaportData;
+export declare const seaportValue: BigNumber;

package/dist/test/orders/x2y2.d.ts

@@ -0,0 +1,6 @@
+export declare const x2y2Orders: {
+    input: string;
+    order_id: number;
+    token_id: string;
+    price: string;
+}[];

package/dist/test/utils/addresses.d.ts

@@ -0,0 +1,2 @@
+export declare const PERMIT2_ADDRESS: string;
+export declare const ROUTER_ADDRESS: string;

package/dist/test/utils/hexToDecimalString.d.ts

@@ -0,0 +1,2 @@
+import { BigNumberish } from 'ethers';
+export declare function hexToDecimalString(hex: BigNumberish): string;

package/dist/test/utils/permit2.d.ts

@@ -0,0 +1,6 @@
+import { Wallet } from 'ethers';
+import { PermitSingle } from '@uniswap/permit2-sdk';
+import { Permit2Permit } from '../../src/utils/permit2';
+export declare function generatePermitSignature(permit: PermitSingle, signer: Wallet, chainId: number, permitAddress?: string): Promise<string>;
+export declare function toInputPermit(signature: string, permit: PermitSingle): Permit2Permit;
+export declare function makePermit(token: string, amount?: string, nonce?: string, routerAddress?: string): PermitSingle;

package/dist/test/utils/uniswapData.d.ts

@@ -0,0 +1,24 @@
+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 RECIPIENT = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+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

@@ -62,6 +62,7 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
 (function (RouterTradeType) {
   RouterTradeType["UniswapTrade"] = "UniswapTrade";
   RouterTradeType["NFTTrade"] = "NFTTrade";
+  RouterTradeType["UnwrapWETH"] = "UnwrapWETH";
 })(exports.RouterTradeType || (exports.RouterTradeType = {}));
 
 var _ABI_DEFINITION;
@@ -137,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
@@ -164,6 +165,33 @@ 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';
@@ -349,7 +377,9 @@ var SwapRouter = /*#__PURE__*/function () {
     var transactionValue = ethers.BigNumber.from(0);
     for (var _iterator = _createForOfIteratorHelperLoose(trades), _step; !(_step = _iterator()).done;) {
       var trade = _step.value;
-      // is NFTTrade
+      /**
+       * is NFTTrade
+       */
       if (trade.tradeType == exports.RouterTradeType.NFTTrade) {
         var nftTrade = trade;
         nftTrade.encode(planner, {
@@ -363,7 +393,9 @@ var SwapRouter = /*#__PURE__*/function () {
         } else {
           currentNativeValueInRouter = currentNativeValueInRouter.sub(tradePrice);
         }
-        // is UniswapTrade
+        /**
+         * is Uniswap Trade
+         */
       } else if (trade.tradeType == exports.RouterTradeType.UniswapTrade) {
         var uniswapTrade = trade;
         var inputIsNative = uniswapTrade.trade.inputAmount.currency.isNative;
@@ -383,6 +415,18 @@ var SwapRouter = /*#__PURE__*/function () {
         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';
       }
@@ -9362,5 +9406,6 @@ 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