@uniswap/universal-router-sdk 0.0.1

package/README.md

@@ -0,0 +1 @@
+# narhwal-sdk

package/dist/entities/Command.d.ts

@@ -0,0 +1,7 @@
+import { RoutePlanner } from '../utils/routerCommands';
+export declare type TradeConfig = {
+    allowRevert: boolean;
+};
+export interface Command {
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+}

package/dist/entities/NFTTrade.d.ts

@@ -0,0 +1,41 @@
+import { 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 { 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 orders: T[];
+    readonly market: Market;
+    constructor(market: Market, orders: T[]);
+    abstract encode(planner: RoutePlanner, config: TradeConfig): void;
+    abstract getBuyItems(): BuyItem[];
+    abstract getTotalPrice(): BigNumberish;
+}
+export declare type BuyItem = {
+    tokenAddress: string;
+    tokenId: BigNumberish;
+    tokenType: TokenType;
+    amount?: BigNumberish;
+};
+export declare enum Market {
+    Foundation = "foundation",
+    LooksRare = "looksrare",
+    NFT20 = "nft20",
+    NFTX = "nftx",
+    Seaport = "seaport",
+    Sudoswap = "Sudoswap",
+    Cryptopunks = "cryptopunks",
+    X2Y2 = "x2y2"
+}
+export declare enum TokenType {
+    ERC721 = "ERC721",
+    ERC1155 = "ERC1155",
+    Cryptopunk = "Cryptopunk"
+}

package/dist/entities/index.d.ts

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

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

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

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

@@ -0,0 +1,19 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumberish } from 'ethers';
+export declare type FoundationData = {
+    recipient: string;
+    tokenAddress: string;
+    tokenId: BigNumberish;
+    price: BigNumberish;
+    referrer: string;
+};
+export declare class FoundationTrade extends NFTTrade<FoundationData> {
+    static INTERFACE: Interface;
+    constructor(orders: FoundationData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}

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

@@ -0,0 +1,9 @@
+export * from './cryptopunk';
+export * from './foundation';
+export * from './looksRare';
+export * from './nft20';
+export * from './nftx';
+export * from './seaport';
+export * from './uniswap';
+export * from './sudoswap';
+export * from './x2y2';

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

@@ -0,0 +1,44 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade, TokenType } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumberish } from 'ethers';
+export declare type MakerOrder = {
+    collection: string;
+    tokenId: BigNumberish;
+    isOrderAsk: true;
+    signer: string;
+    strategy: string;
+    currency: string;
+    amount: BigNumberish;
+    price: BigNumberish;
+    minPercentageToAsk: BigNumberish;
+    nonce: BigNumberish;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    v: BigNumberish;
+    r: string;
+    s: string;
+    params: string;
+};
+export declare type TakerOrder = {
+    minPercentageToAsk: BigNumberish;
+    price: BigNumberish;
+    taker: string;
+    tokenId: BigNumberish;
+    isOrderAsk: boolean;
+    params: string;
+};
+export declare type LooksRareData = {
+    makerOrder: MakerOrder;
+    takerOrder: TakerOrder;
+    recipient: string;
+    tokenType: TokenType;
+};
+export declare class LooksRareTrade extends NFTTrade<LooksRareData> {
+    static INTERFACE: Interface;
+    constructor(orders: LooksRareData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}

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

@@ -0,0 +1,21 @@
+import { Interface } from '@ethersproject/abi';
+import { TradeConfig } from '../Command';
+import { NFTTrade, BuyItem } from '../NFTTrade';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumberish } from 'ethers';
+export declare type NFT20Data = {
+    tokenAddress: string;
+    tokenIds: BigNumberish[];
+    tokenAmounts: BigNumberish[];
+    recipient: string;
+    fee: BigNumberish;
+    isV3: boolean;
+    value: BigNumberish;
+};
+export declare class NFT20Trade extends NFTTrade<NFT20Data> {
+    static INTERFACE: Interface;
+    constructor(orders: NFT20Data[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}

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

@@ -0,0 +1,20 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+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;
+};
+export declare class NFTXTrade extends NFTTrade<NFTXData> {
+    static INTERFACE: Interface;
+    constructor(orders: NFTXData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}

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

@@ -0,0 +1,57 @@
+import { BigNumber, BigNumberish } from 'ethers';
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+export declare type SeaportData = {
+    items: Order[];
+    recipient: string;
+};
+export declare type FulfillmentComponent = {
+    orderIndex: BigNumberish;
+    itemIndex: BigNumberish;
+};
+export declare type OfferItem = {
+    itemType: BigNumberish;
+    token: string;
+    identifierOrCriteria: BigNumberish;
+    startAmount: BigNumberish;
+    endAmount: BigNumberish;
+};
+export declare type ConsiderationItem = OfferItem & {
+    recipient: string;
+};
+export declare type Order = {
+    parameters: OrderParameters;
+    signature: string;
+};
+declare type OrderParameters = {
+    offerer: string;
+    offer: OfferItem[];
+    consideration: ConsiderationItem[];
+    orderType: BigNumberish;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    zoneHash: string;
+    zone: string;
+    salt: BigNumberish;
+    conduitKey: string;
+    totalOriginalConsiderationItems: BigNumberish;
+};
+export declare type AdvancedOrder = Order & {
+    numerator: BigNumber;
+    denominator: BigNumber;
+    extraData: string;
+};
+export declare class SeaportTrade extends NFTTrade<SeaportData> {
+    static INTERFACE: Interface;
+    static OPENSEA_CONDUIT_KEY: string;
+    constructor(orders: SeaportData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumber;
+    private getConsiderationFulfillments;
+    private getAdvancedOrderParams;
+    private calculateValue;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumberish } from 'ethers';
+declare type PairSwap = {
+    swapInfo: {
+        pair: string;
+        nftIds: BigNumberish[];
+    };
+    tokenAddress: string;
+    maxCost: BigNumberish;
+};
+export declare type SudoswapData = {
+    swaps: PairSwap[];
+    nftRecipient: string;
+    ethRecipient: string;
+    deadline: BigNumberish;
+};
+export declare class SudoswapTrade extends NFTTrade<SudoswapData> {
+    static INTERFACE: Interface;
+    constructor(orders: SudoswapData[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}
+export {};

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

@@ -0,0 +1,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';
+export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
+    inputTokenPermit?: Permit2Permit;
+};
+export declare class UniswapTrade implements Command {
+    trade: RouterTrade<Currency, Currency, TradeType>;
+    options: SwapOptions;
+    constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
+    encode(planner: RoutePlanner, _config: TradeConfig): void;
+}

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

@@ -0,0 +1,28 @@
+import { Interface } from '@ethersproject/abi';
+import { BuyItem, NFTTrade, TokenType } from '../NFTTrade';
+import { TradeConfig } from '../Command';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { BigNumberish } from 'ethers';
+declare type X2Y2PartialData = {
+    signedInput: string;
+    recipient: string;
+    tokenAddress: string;
+    tokenId: BigNumberish;
+    price: BigNumberish;
+};
+export declare type X2Y2_721_Data = X2Y2PartialData & {
+    tokenType: TokenType.ERC721;
+};
+export declare type X2Y2_1155_Data = X2Y2PartialData & {
+    tokenType: TokenType.ERC1155;
+    tokenAmount: BigNumberish;
+};
+export declare type X2Y2Data = X2Y2_721_Data | X2Y2_1155_Data;
+export declare class X2Y2Trade extends NFTTrade<X2Y2Data> {
+    static INTERFACE: Interface;
+    constructor(orders: X2Y2Data[]);
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+    getBuyItems(): BuyItem[];
+    getTotalPrice(): BigNumberish;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { SwapRouter } from './swapRouter';
+export * from './entities';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./universal-router-sdk.cjs.production.min.js')
+} else {
+  module.exports = require('./universal-router-sdk.cjs.development.js')
+}

package/dist/swapRouter.d.ts

@@ -0,0 +1,32 @@
+import { Interface } from '@ethersproject/abi';
+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 { NFTTrade, SupportedProtocolsData } from './entities/NFTTrade';
+import { SwapOptions } from './entities/protocols/uniswap';
+export declare type SwapRouterConfig = {
+    sender?: string;
+    deadline?: BigNumberish;
+};
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    /**
+     * 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 swapGenieCallParameters(trades: NFTTrade<SupportedProtocolsData>[], config: SwapRouterConfig): MethodParameters;
+    /**
+     * 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
+     */
+    static swapERC20CallParameters(trades: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions): MethodParameters;
+    /**
+     * Encodes a planned route into a method name and parameters for the Router contract.
+     * @param planner the planned route
+     * @param nativeCurrencyValue the native currency value of the planned route
+     * @param config the router config
+     */
+    private static encodePlan;
+}