@uniswap/universal-router-sdk 1.4.4 → 1.5.0-beta.1

package/dist/entities/NFTTrade.d.ts

@@ -5,11 +5,12 @@ import { NFTXData } from './protocols/nftx';
 import { NFT20Data } from './protocols/nft20';
 import { RoutePlanner } from '../utils/routerCommands';
 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;
+import { ElementData } from './protocols/element-market';
+import { LooksRareV2Data } from './protocols/looksRareV2';
+export declare type SupportedProtocolsData = SeaportData | FoundationData | NFTXData | LooksRareV2Data | X2Y2Data | CryptopunkData | NFT20Data | SudoswapData | ElementData;
 export declare abstract class NFTTrade<T> implements Command {
     readonly tradeType: RouterTradeType;
     readonly orders: T[];
@@ -17,7 +18,7 @@ export declare abstract class NFTTrade<T> implements Command {
     constructor(market: Market, orders: T[]);
     abstract encode(planner: RoutePlanner, config: TradeConfig): void;
     abstract getBuyItems(): BuyItem[];
-    abstract getTotalPrice(): BigNumber;
+    abstract getTotalPrice(token?: string): BigNumber;
 }
 export declare type BuyItem = {
     tokenAddress: string;
@@ -27,13 +28,14 @@ export declare type BuyItem = {
 };
 export declare enum Market {
     Foundation = "foundation",
-    LooksRare = "looksrare",
+    LooksRareV2 = "looksrareV2",
     NFT20 = "nft20",
     NFTX = "nftx",
     Seaport = "seaport",
     Sudoswap = "Sudoswap",
     Cryptopunks = "cryptopunks",
-    X2Y2 = "x2y2"
+    X2Y2 = "x2y2",
+    Element = "element"
 }
 export declare enum TokenType {
     ERC721 = "ERC721",

package/dist/entities/protocols/element-market.d.ts

@@ -0,0 +1,44 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumber } from 'ethers';
+export interface Fee {
+    recipient: string;
+    amount: string;
+    feeData: string;
+}
+declare type ElementPartialData = {
+    maker: string;
+    taker: string;
+    expiry: string;
+    nonce: string;
+    erc20Token: string;
+    erc20TokenAmount: string;
+    fees: Fee[];
+};
+export declare type ERC721SellOrder = ElementPartialData & {
+    nft: string;
+    nftId: string;
+};
+export declare type OrderSignature = {
+    signatureType: number;
+    v: number;
+    r: string;
+    s: string;
+};
+export declare type ElementData = {
+    order: ERC721SellOrder;
+    signature: OrderSignature;
+    recipient: string;
+};
+export declare class ElementTrade extends NFTTrade<ElementData> {
+    private static ETH_ADDRESS;
+    static INTERFACE: Interface;
+    constructor(orders: ElementData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumber;
+    getOrderPriceIncludingFees(order: ERC721SellOrder): BigNumber;
+}
+export {};

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

@@ -1,6 +1,6 @@
 export * from './cryptopunk';
 export * from './foundation';
-export * from './looksRare';
+export * from './looksRareV2';
 export * from './nft20';
 export * from './nftx';
 export * from './seaport';

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

@@ -0,0 +1,56 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumber } from 'ethers';
+export declare type MakerOrder = {
+    quoteType: number;
+    globalNonce: string;
+    subsetNonce: string;
+    orderNonce: string;
+    strategyId: number;
+    collectionType: number;
+    collection: string;
+    currency: string;
+    signer: string;
+    startTime: number;
+    endTime: number;
+    price: string;
+    itemIds: string[];
+    amounts: string[];
+    additionalParameters: string;
+};
+export declare type TakerOrder = {
+    recipient: string;
+    additionalParameters: string;
+};
+export declare type MerkleProof = {
+    value: string;
+    position: number;
+};
+export declare type MerkleTree = {
+    root: string;
+    proof: MerkleProof[];
+};
+export declare type LRV2APIOrder = MakerOrder & {
+    id: string;
+    hash: string;
+    signature: string;
+    createdAt: string;
+    merkleRoot: string;
+    merkleProof: MerkleProof[];
+    status: string;
+};
+export declare type LooksRareV2Data = {
+    apiOrder: LRV2APIOrder;
+    taker: string;
+};
+export declare class LooksRareV2Trade extends NFTTrade<LooksRareV2Data> {
+    static INTERFACE: Interface;
+    private static ERC721_ORDER;
+    constructor(orders: LooksRareV2Data[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumber;
+    private refactorAPIData;
+}

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

@@ -5,11 +5,11 @@ import { RoutePlanner } from '../../utils/routerCommands';
 import { BigNumber, BigNumberish } from 'ethers';
 export declare type NFTXData = {
     recipient: string;
-    vaultAddress: string;
     vaultId: BigNumberish;
     tokenAddress: string;
     tokenIds: BigNumberish[];
     value: BigNumber;
+    swapCalldata: string;
 };
 export declare class NFTXTrade extends NFTTrade<NFTXData> {
     static INTERFACE: Interface;

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

@@ -3,14 +3,18 @@ import { Interface } from '@ethersproject/abi';
 import { BuyItem, NFTTrade } from '../NFTTrade';
 import { TradeConfig } from '../Command';
 import { RoutePlanner } from '../../utils/routerCommands';
-export declare enum SeaportVersion {
-    V1_1 = 0,
-    V1_4 = 1
-}
+import { Permit2Permit } from '../../utils/inputTokens';
 export declare type SeaportData = {
     items: Order[];
     recipient: string;
-    version: SeaportVersion;
+    protocolAddress: string;
+    inputTokenProcessing?: InputTokenProcessing[];
+};
+export declare type InputTokenProcessing = {
+    token: string;
+    permit2Permit?: Permit2Permit;
+    protocolApproval: boolean;
+    permit2TransferFrom: boolean;
 };
 export declare type FulfillmentComponent = {
     orderIndex: BigNumberish;
@@ -54,8 +58,8 @@ export declare class SeaportTrade extends NFTTrade<SeaportData> {
     constructor(orders: SeaportData[]);
     encode(planner: RoutePlanner, config: TradeConfig): void;
     getBuyItems(): BuyItem[];
-    getTotalOrderPrice(order: SeaportData): BigNumber;
-    getTotalPrice(): BigNumber;
+    getTotalOrderPrice(order: SeaportData, token?: string): BigNumber;
+    getTotalPrice(token?: string): BigNumber;
     private commandMap;
     private getConsiderationFulfillments;
     private getAdvancedOrderParams;

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

@@ -1,6 +1,6 @@
 import { RoutePlanner } from '../../utils/routerCommands';
 import { Trade as RouterTrade, SwapOptions as RouterSwapOptions } from '@uniswap/router-sdk';
-import { Permit2Permit } from '../../utils/permit2';
+import { Permit2Permit } from '../../utils/inputTokens';
 import { Currency, TradeType } from '@uniswap/sdk-core';
 import { Command, RouterTradeType, TradeConfig } from '../Command';
 export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {

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

@@ -1,12 +1,11 @@
 import { BigNumberish } from 'ethers';
 import { RoutePlanner } from '../../utils/routerCommands';
-import { Permit2Permit } from '../../utils/permit2';
+import { Permit2Permit } from '../../utils/inputTokens';
 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/test/orders/element.d.ts

@@ -0,0 +1,7 @@
+import { ElementData, OrderSignature, ERC721SellOrder } from '../../src/entities/protocols/element-market';
+export declare const elementOrderETH: ERC721SellOrder;
+export declare const elementSignatureETH: OrderSignature;
+export declare const elementOrderETH_WithFees: ERC721SellOrder;
+export declare const elementOrderETH_WithFees_Signature: OrderSignature;
+export declare const elementDataETH: ElementData;
+export declare const elementDataETH_WithFees: ElementData;

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

@@ -0,0 +1,2 @@
+import { LRV2APIOrder } from '../../src/entities/protocols/looksRareV2';
+export declare const looksRareV2Orders: LRV2APIOrder[];

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

@@ -1,4 +1,5 @@
-import { SeaportData } from '../../src/entities/protocols/seaport';
+import { ConsiderationItem, SeaportData } from '../../src/entities/protocols/seaport';
 import { BigNumber } from 'ethers';
-export declare const seaportData2Covens: SeaportData;
-export declare const seaportValue: BigNumber;
+export declare const seaportDataETH: SeaportData;
+export declare const seaportDataERC20: SeaportData;
+export declare function calculateSeaportValue(considerations: ConsiderationItem[], token: string): BigNumber;

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

@@ -1,4 +1,3 @@
 import { SeaportData } from '../../src/entities/protocols/seaport';
-import { BigNumber } from 'ethers';
-export declare const seaportV1_4Data: SeaportData;
-export declare const seaportV1_4Value: BigNumber;
+export declare const seaportV1_4DataETH: SeaportData;
+export declare const seaportV1_4DataETHRecent: SeaportData;

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

@@ -1,2 +1,7 @@
+export declare const MAINNET_ROUTER_ADDRESS: string;
+export declare const FORGE_ROUTER_ADDRESS = "0xe808c1cfeebb6cb36b537b82fa7c9eef31415a05";
+export declare const FORGE_PERMIT2_ADDRESS = "0x4a873bdd49f7f9cc0a5458416a12973fab208f8d";
+export declare const FORGE_SENDER_ADDRESS = "0xcf03dd0a894ef79cb5b601a43c4b25e3ae4c67ed";
+export declare const TEST_RECIPIENT_ADDRESS = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 export declare const PERMIT2_ADDRESS: string;
 export declare const ROUTER_ADDRESS: string;

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

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

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

@@ -4,7 +4,6 @@ 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;