@uniswap/router-sdk 2.7.3 → 2.9.0

package/dist/types/src/entities/trade.d.ts

@@ -0,0 +1,136 @@
+import { Currency, CurrencyAmount, Percent, Price, TradeType } from '@uniswap/sdk-core';
+import { Pair, Route as V2RouteSDK } from '@uniswap/v2-sdk';
+import { Pool as V3Pool, Route as V3RouteSDK } from '@uniswap/v3-sdk';
+import { Pool as V4Pool, Route as V4RouteSDK } from '@uniswap/v4-sdk';
+import { MixedRouteSDK } from './mixedRoute/route';
+import { IRoute } from './route';
+export declare class Trade<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType> {
+    readonly routes: IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    readonly tradeType: TTradeType;
+    private _outputAmount;
+    private _inputAmount;
+    private _nativeInputRoutes;
+    private _wethInputRoutes;
+    /**
+     * The swaps of the trade, i.e. which routes and how much is swapped in each that
+     * make up the trade. May consist of swaps in v2 or v3.
+     */
+    readonly swaps: {
+        route: IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>;
+        inputAmount: CurrencyAmount<TInput>;
+        outputAmount: CurrencyAmount<TOutput>;
+        maxHopSlippage?: bigint[];
+    }[];
+    constructor({ v2Routes, v3Routes, v4Routes, mixedRoutes, tradeType, }: {
+        v2Routes?: {
+            routev2: V2RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+            maxHopSlippage?: bigint[];
+        }[];
+        v3Routes?: {
+            routev3: V3RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+            maxHopSlippage?: bigint[];
+        }[];
+        v4Routes?: {
+            routev4: V4RouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+            maxHopSlippage?: bigint[];
+        }[];
+        mixedRoutes?: {
+            mixedRoute: MixedRouteSDK<TInput, TOutput>;
+            inputAmount: CurrencyAmount<TInput>;
+            outputAmount: CurrencyAmount<TOutput>;
+            maxHopSlippage?: bigint[];
+        }[];
+        tradeType: TTradeType;
+    });
+    get inputAmount(): CurrencyAmount<TInput>;
+    get outputAmount(): CurrencyAmount<TOutput>;
+    /**
+     * Returns the sum of all swaps within the trade
+     * @returns
+     * inputAmount: total input amount
+     * inputAmountNative: total amount of native currency required for ETH input paths
+     *  - 0 if inputAmount is native but no native input paths
+     *  - undefined if inputAmount is not native
+     * outputAmount: total output amount
+     * outputAmountNative: total amount of native currency returned from ETH output paths
+     *  - 0 if outputAmount is native but no native output paths
+     *  - undefined if outputAmount is not native
+     */
+    get amounts(): {
+        inputAmount: CurrencyAmount<TInput>;
+        inputAmountNative: CurrencyAmount<TInput> | undefined;
+        outputAmount: CurrencyAmount<TOutput>;
+        outputAmountNative: CurrencyAmount<TOutput> | undefined;
+    };
+    get numberOfInputWraps(): number;
+    get numberOfInputUnwraps(): number;
+    get nativeInputRoutes(): IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    get wethInputRoutes(): IRoute<TInput, TOutput, Pair | V3Pool | V4Pool>[];
+    private _executionPrice;
+    /**
+     * The price expressed in terms of output amount/input amount.
+     */
+    get executionPrice(): Price<TInput, TOutput>;
+    /**
+     * Returns the sell tax of the input token
+     */
+    get inputTax(): Percent;
+    /**
+     * Returns the buy tax of the output token
+     */
+    get outputTax(): Percent;
+    private isWrappedNative;
+    /**
+     * The cached result of the price impact computation
+     * @private
+     */
+    private _priceImpact;
+    /**
+     * Returns the percent difference between the route's mid price and the expected execution price
+     * In order to exclude token taxes from the price impact calculation, the spot price is calculated
+     * using a ratio of values that go into the pools, which are the post-tax input amount and pre-tax output amount.
+     */
+    get priceImpact(): Percent;
+    /**
+     * Get the minimum amount that must be received from this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount out
+     */
+    minimumAmountOut(slippageTolerance: Percent, amountOut?: CurrencyAmount<TOutput>): CurrencyAmount<TOutput>;
+    /**
+     * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+     * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+     * @returns The amount in
+     */
+    maximumAmountIn(slippageTolerance: Percent, amountIn?: CurrencyAmount<TInput>): CurrencyAmount<TInput>;
+    /**
+     * Return the execution price after accounting for slippage tolerance
+     * @param slippageTolerance the allowed tolerated slippage
+     * @returns The execution price
+     */
+    worstExecutionPrice(slippageTolerance: Percent): Price<TInput, TOutput>;
+    static fromRoutes<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(v2Routes: {
+        routev2: V2RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        maxHopSlippage?: bigint[];
+    }[], v3Routes: {
+        routev3: V3RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        maxHopSlippage?: bigint[];
+    }[], tradeType: TTradeType, mixedRoutes?: {
+        mixedRoute: MixedRouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        maxHopSlippage?: bigint[];
+    }[], v4Routes?: {
+        routev4: V4RouteSDK<TInput, TOutput>;
+        amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>;
+        maxHopSlippage?: bigint[];
+    }[]): Promise<Trade<TInput, TOutput, TTradeType>>;
+    static fromRoute<TInput extends Currency, TOutput extends Currency, TTradeType extends TradeType>(route: V2RouteSDK<TInput, TOutput> | V3RouteSDK<TInput, TOutput> | V4RouteSDK<TInput, TOutput> | MixedRouteSDK<TInput, TOutput>, amount: TTradeType extends TradeType.EXACT_INPUT ? CurrencyAmount<TInput> : CurrencyAmount<TOutput>, tradeType: TTradeType): Promise<Trade<TInput, TOutput, TTradeType>>;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './constants';
+export * from './approveAndCall';
+export * from './multicallExtended';
+export * from './paymentsExtended';
+export * from './swapRouter';
+export * from './entities/trade';
+export * from './entities/protocol';
+export * from './entities/route';
+export * from './entities/mixedRoute/route';
+export * from './entities/mixedRoute/trade';
+export * from './utils/encodeMixedRouteToPath';
+export * from './utils/TPool';
+export * from './utils/pathCurrency';
+export * from './utils';

package/dist/types/src/multicallExtended.d.ts

@@ -0,0 +1,11 @@
+import { Interface } from '@ethersproject/abi';
+import { BigintIsh } from '@uniswap/sdk-core';
+export type Validation = BigintIsh | string;
+export declare abstract class MulticallExtended {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeMulticall(calldatas: string | string[], validation?: Validation): string;
+}

package/dist/types/src/paymentsExtended.d.ts

@@ -0,0 +1,15 @@
+import { Interface } from '@ethersproject/abi';
+import { Token } from '@uniswap/sdk-core';
+import { FeeOptions } from '@uniswap/v3-sdk';
+import JSBI from 'jsbi';
+export declare abstract class PaymentsExtended {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static encodeUnwrapWETH9(amountMinimum: JSBI, recipient?: string, feeOptions?: FeeOptions): string;
+    static encodeSweepToken(token: Token, amountMinimum: JSBI, recipient?: string, feeOptions?: FeeOptions): string;
+    static encodePull(token: Token, amount: JSBI): string;
+    static encodeWrapETH(amount: JSBI): string;
+}

package/dist/types/src/swapRouter.d.ts

@@ -0,0 +1,95 @@
+import { Interface } from '@ethersproject/abi';
+import { Currency, Percent, TradeType } from '@uniswap/sdk-core';
+import { Trade as V2Trade } from '@uniswap/v2-sdk';
+import { FeeOptions, MethodParameters, PermitOptions, Position, Trade as V3Trade } from '@uniswap/v3-sdk';
+import { ApprovalTypes, CondensedAddLiquidityOptions } from './approveAndCall';
+import { Trade } from './entities/trade';
+import { Validation } from './multicallExtended';
+import { MixedRouteTrade } from './entities/mixedRoute/trade';
+/**
+ * Options for producing the arguments to send calls to the router.
+ */
+export interface SwapOptions {
+    /**
+     * How much the execution price is allowed to move unfavorably from the trade execution price.
+     */
+    slippageTolerance: Percent;
+    /**
+     * The account that should receive the output. If omitted, output is sent to msg.sender.
+     */
+    recipient?: string;
+    /**
+     * Either deadline (when the transaction expires, in epoch seconds), or previousBlockhash.
+     */
+    deadlineOrPreviousBlockhash?: Validation;
+    /**
+     * The optional permit parameters for spending the input.
+     */
+    inputTokenPermit?: PermitOptions;
+    /**
+     * Optional information for taking a fee on output.
+     */
+    fee?: FeeOptions;
+}
+export interface SwapAndAddOptions extends SwapOptions {
+    /**
+     * The optional permit parameters for pulling in remaining output token.
+     */
+    outputTokenPermit?: PermitOptions;
+}
+type AnyTradeType = Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[];
+/**
+ * Represents the Uniswap V2 + V3 SwapRouter02, and has static methods for helping execute trades.
+ */
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * @notice Generates the calldata for a Swap with a V2 Route.
+     * @param trade The V2Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeV2Swap;
+    /**
+     * @notice Generates the calldata for a Swap with a V3 Route.
+     * @param trade The V3Trade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeV3Swap;
+    /**
+     * @notice Generates the calldata for a MixedRouteSwap. Since single hop routes are not MixedRoutes, we will instead generate
+     *         them via the existing encodeV3Swap and encodeV2Swap methods.
+     * @param trade The MixedRouteTrade to encode.
+     * @param options SwapOptions to use for the trade.
+     * @param routerMustCustody Flag for whether funds should be sent to the router
+     * @param performAggregatedSlippageCheck Flag for whether we want to perform an aggregated slippage check
+     * @returns A string array of calldatas for the trade.
+     */
+    private static encodeMixedRouteSwap;
+    private static encodeSwaps;
+    /**
+     * 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 swapCallParameters(trades: Trade<Currency, Currency, TradeType> | V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType> | (V2Trade<Currency, Currency, TradeType> | V3Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[], options: SwapOptions): 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 swapAndAddCallParameters(trades: AnyTradeType, options: SwapAndAddOptions, position: Position, addLiquidityOptions: CondensedAddLiquidityOptions, tokenInApprovalType: ApprovalTypes, tokenOutApprovalType: ApprovalTypes): MethodParameters;
+    private static riskOfPartialFill;
+    private static v3TradeWithHighPriceImpact;
+    private static getPositionAmounts;
+}
+export {};

package/dist/types/src/utils/TPool.d.ts

@@ -0,0 +1,4 @@
+import { Pool as V4Pool } from '@uniswap/v4-sdk';
+import { Pair } from '@uniswap/v2-sdk';
+import { Pool as V3Pool } from '@uniswap/v3-sdk';
+export type TPool = Pair | V3Pool | V4Pool;

package/dist/types/src/utils/encodeMixedRouteToPath.d.ts

@@ -0,0 +1,10 @@
+import { Currency } from '@uniswap/sdk-core';
+import { MixedRouteSDK } from '../entities/mixedRoute/route';
+/**
+ * Converts a route to a hex encoded path
+ * @notice only supports exactIn route encodings
+ * @param route the mixed path to convert to an encoded path
+ * @param useMixedRouterQuoteV2 if true, uses the Mixed Quoter V2 encoding for v4 pools. By default, we do not set it. This is only used in SOR for explicit setting during onchain quoting.
+ * @returns the exactIn encoded path
+ */
+export declare function encodeMixedRouteToPath(route: MixedRouteSDK<Currency, Currency>, useMixedRouterQuoteV2?: boolean): string;

package/dist/types/src/utils/index.d.ts

@@ -0,0 +1,16 @@
+import { Currency } from '@uniswap/sdk-core';
+import { MixedRouteSDK } from '../entities/mixedRoute/route';
+import { TPool } from './TPool';
+/**
+ * Utility function to return each consecutive section of Pools or Pairs in a MixedRoute
+ * @param route
+ * @returns a nested array of Pools or Pairs in the order of the route
+ */
+export declare const partitionMixedRouteByProtocol: (route: MixedRouteSDK<Currency, Currency>) => TPool[][];
+/**
+ * Simple utility function to get the output of an array of Pools or Pairs
+ * @param pools
+ * @param firstInputToken
+ * @returns the output token of the last pool in the array
+ */
+export declare const getOutputOfPools: (pools: TPool[], firstInputToken: Currency) => Currency;

package/dist/types/src/utils/pathCurrency.d.ts

@@ -0,0 +1,4 @@
+import { Currency, CurrencyAmount } from '@uniswap/sdk-core';
+import { TPool } from './TPool';
+export declare function amountWithPathCurrency(amount: CurrencyAmount<Currency>, pool: TPool): CurrencyAmount<Currency>;
+export declare function getPathCurrency(currency: Currency, pool: TPool): Currency;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniswap/router-sdk",
-  "version": "2.7.3",
+  "version": "2.9.0",
   "description": "An sdk for routing swaps using Uniswap v2 and Uniswap v3.",
   "repository": "https://github.com/Uniswap/sdks.git",
   "keywords": [
@@ -8,32 +8,51 @@
     "ethereum"
   ],
   "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "./dist/cjs/src/index.js",
+  "typings": "./dist/types/src/index.d.ts",
+  "module": "./dist/esm/src/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/esm/src/index.js",
+      "require": "./dist/cjs/src/index.js"
+    }
+  },
+  "sideEffects": false,
   "files": [
     "dist"
   ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
-    "build": "tsdx build",
+    "build": "bun run clean && tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json && tsc -p tsconfig.types.json",
+    "clean": "rm -rf dist",
     "lint": "eslint 'src/**/*.{js,ts,tsx}' --max-warnings 0",
     "release": "changeset publish",
-    "start": "tsdx watch",
-    "test": "tsdx test"
+    "test": "bun test"
   },
   "dependencies": {
     "@ethersproject/abi": "^5.5.0",
-    "@uniswap/sdk-core": "workspace:*",
+    "@ethersproject/solidity": "^5.0.9",
+    "@uniswap/sdk-core": "^7.13.0",
     "@uniswap/swap-router-contracts": "^1.3.0",
-    "@uniswap/v2-sdk": "workspace:*",
-    "@uniswap/v3-sdk": "workspace:*",
-    "@uniswap/v4-sdk": "workspace:*"
+    "@uniswap/v2-sdk": "^4.20.0",
+    "@uniswap/v3-sdk": "^3.30.0",
+    "@uniswap/v4-sdk": "^2.0.0",
+    "jsbi": "^3.1.4",
+    "tiny-invariant": "^1.1.0",
+    "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "@types/jest": "^24.0.25",
+    "@ethersproject/bignumber": "^5.5.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
+    "eslint-config-react-app": "7.0.1",
     "eslint-plugin-prettier": "^3.4.1",
     "prettier": "^2.4.1",
-    "tsdx": "^0.14.1"
+    "typescript": "^4.3.3"
   },
   "prettier": {
     "printWidth": 120,

package/dist/index.js

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