@uniswap/universal-router-sdk 1.3.0 → 1.3.2

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,66 @@ 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])
+```
+
+### 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`
 Install dependencies and run typescript unit tests

package/dist/entities/Command.d.ts

@@ -2,6 +2,12 @@ import { RoutePlanner } from '../utils/routerCommands';
 export declare type TradeConfig = {
     allowRevert: boolean;
 };
+export declare enum RouterTradeType {
+    UniswapTrade = "UniswapTrade",
+    NFTTrade = "NFTTrade",
+    UnwrapWETH = "UnwrapWETH"
+}
 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/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/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, WETH_ADDRESS } 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/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 {};