@uniswap/universal-router-sdk 4.34.1 → 4.35.0

package/README.md

@@ -39,71 +39,87 @@ forge install
 yarn test:forge
 ```
 
-## Per-Hop Slippage Protection (V4 Routes)
+## Per-Hop Slippage Protection
 
-Universal Router v2.1 adds granular slippage protection for multi-hop V4 swaps. Additionally to checking slippage at the end of a route, you can now verify that each individual hop doesn't exceed a maximum price limit.
+Universal Router v2.1.1 adds granular slippage protection for multi-hop swaps across all protocol versions (V2, V3, V4, and mixed routes). In addition to the overall trade-level slippage check, the contract can verify that each individual pool hop doesn't exceed a maximum price limit.
 
 ### How It Works
 
-For V4 multi-hop swaps, you can provide a `maxHopSlippage` array in your swap options:
+Per-hop slippage bounds live on each swap's route data (via `RouterTrade`). The `maxHopSlippage` array on each route maps 1:1 to the route's pools: `maxHopSlippage[i]` constrains `route.pools[i]`.
+
+To enable the V2.1.1 ABI encoding (which includes the `maxHopSlippage` parameter), set `urVersion: URVersion.V2_1_1` on your swap options.
 
 ```typescript
 import { SwapRouter } from '@uniswap/universal-router-sdk'
-import { BigNumber } from 'ethers'
-import { Percent } from '@uniswap/sdk-core'
+import { Trade as RouterTrade } from '@uniswap/router-sdk'
+import { URVersion } from '@uniswap/v4-sdk'
+import { Percent, TradeType } from '@uniswap/sdk-core'
 
-const swapOptions = {
+// 1. Build a trade with per-hop slippage on each route
+const trade = new RouterTrade({
+  v3Routes: [
+    {
+      routev3: myV3Route, // e.g. USDC → DAI → WETH
+      inputAmount,
+      outputAmount,
+      maxHopSlippage: [
+        // one entry per pool in the route
+        BigInt('1010000000000000000'), // Hop 0: USDC→DAI, max price 1.01
+        BigInt('2500000000000000000000'), // Hop 1: DAI→WETH, max price 2500
+      ],
+    },
+  ],
+  tradeType: TradeType.EXACT_INPUT,
+})
+
+// 2. Encode with V2.1.1 ABI
+const { calldata, value } = SwapRouter.swapCallParameters(trade, {
   slippageTolerance: new Percent(50, 10000), // 0.5% overall slippage
   recipient: '0x...',
-  deadline: Math.floor(Date.now() / 1000) + 60 * 20,
-  // Optional: per-hop slippage protection for V4 routes
-  maxHopSlippage: [
-    BigNumber.from('1010000000000000000'),    // Hop 0: max price 1.01 (1% slippage)
-    BigNumber.from('2500000000000000000000'),  // Hop 1: max price 2500
-  ]
-}
-
-const { calldata, value } = SwapRouter.swapCallParameters(trade, swapOptions)
+  urVersion: URVersion.V2_1_1, // required for per-hop encoding
+})
 ```
 
 ### Price Calculation
 
-The slippage is expressed as a **price** with 18 decimals of precision:
+Slippage is expressed as a **price** with 18 decimals of precision:
 
-- **For Exact Input**: `price = amountIn * 1e18 / amountOut`
-- **For Exact Output**: `price = amountIn * 1e18 / amountOut`
+- `price = amountIn * 1e18 / amountOut`
 
-If the calculated price exceeds `maxHopSlippage[i]`, the transaction will revert with:
+If the calculated price for hop `i` exceeds `maxHopSlippage[i]`, the transaction reverts.
 
-- `V4TooLittleReceivedPerHop` for exact input swaps
-- `V4TooMuchRequestedPerHop` for exact output swaps
+### Mixed Routes
 
-### Example: USDC → DAI → WETH
+For mixed routes that span multiple protocol versions (e.g. V3 pool → V4 pool → V2 pool), the SDK automatically slices the flat `maxHopSlippage` array by section. Each protocol section receives the corresponding slice of hop bounds:
 
 ```typescript
-// 2-hop swap: USDC → DAI → WETH
-const swapOptions = {
-  slippageTolerance: new Percent(100, 10000), // 1% overall
-  recipient: userAddress,
-  deadline,
-  maxHopSlippage: [
-    BigNumber.from('1010000000000000000'),     // Hop 0: USDC→DAI, max 1% slippage
-    BigNumber.from('2500000000000000000000'),  // Hop 1: DAI→WETH, max price 2500 DAI/WETH
-  ]
-}
+const trade = new RouterTrade({
+  mixedRoutes: [
+    {
+      mixedRoute: myMixedRoute, // V3 pool, V3 pool, V2 pool
+      inputAmount,
+      outputAmount,
+      maxHopSlippage: [
+        BigInt('1010000000000000000'), // Hop 0 (V3 section)
+        BigInt('2500000000000000000000'), // Hop 1 (V3 section)
+        BigInt('1005000000000000000'), // Hop 2 (V2 section)
+      ],
+    },
+  ],
+  tradeType: TradeType.EXACT_INPUT,
+})
 ```
 
 ### Benefits
 
-1. **MEV Protection**: Prevents sandwich attacks on individual hops
-2. **Route Quality**: Ensures each segment of a multi-hop route meets expectations
-3. **Granular Control**: Different slippage tolerance for different pairs in a route
+1. **MEV Protection**: Prevents sandwich attacks on individual pool hops
+2. **Route Quality**: Ensures each segment of a multi-hop route meets price expectations
+3. **Granular Control**: Different slippage tolerances for different pairs (e.g. tighter bounds on stablecoin hops)
 
 ### Backward Compatibility
 
-- If `maxHopSlippage` is not provided or is an empty array, only overall slippage is checked (backward compatible)
-- The feature only applies to V4 routes; V2 and V3 routes ignore this parameter
-- Mixed routes with V4 sections will apply per-hop checks only to the V4 portions
+- If `maxHopSlippage` is omitted or is an empty array, only the overall trade-level slippage is checked
+- If `urVersion` is not set (defaults to V2.0), commands use the standard ABI without `maxHopSlippage`
 
 ## Signed Routes (Universal Router v2.1)
 
@@ -133,9 +149,9 @@ const { calldata, value } = SwapRouter.swapCallParameters(trade, {
 const payload = SwapRouter.getExecuteSignedPayload(
   calldata,
   {
-    intent: '0x' + '0'.repeat(64),  // Application-specific intent
-    data: '0x' + '0'.repeat(64),    // Application-specific data
-    sender: wallet.address,          // Or address(0) to skip sender verification
+    intent: '0x' + '0'.repeat(64), // Application-specific intent
+    data: '0x' + '0'.repeat(64), // Application-specific data
+    sender: wallet.address, // Or address(0) to skip sender verification
   },
   deadline,
   chainId,
@@ -153,7 +169,7 @@ const { calldata: signedCalldata, value: signedValue } = SwapRouter.encodeExecut
     intent: payload.value.intent,
     data: payload.value.data,
     sender: payload.value.sender,
-    nonce: payload.value.nonce,  // Must match what was signed
+    nonce: payload.value.nonce, // Must match what was signed
   },
   deadline,
   BigNumber.from(value)
@@ -182,8 +198,8 @@ const payload = SwapRouter.getExecuteSignedPayload(
   {
     intent: '0x...',
     data: '0x...',
-    sender: '0x0000000000000000000000000000000000000000',  // Skip sender verification too
-    nonce: NONCE_SKIP_CHECK,  // Allow signature reuse
+    sender: '0x0000000000000000000000000000000000000000', // Skip sender verification too
+    nonce: NONCE_SKIP_CHECK, // Allow signature reuse
   },
   deadline,
   chainId,
@@ -209,28 +225,24 @@ import { SwapRouter } from '@uniswap/universal-router-sdk'
 import { BigNumber } from 'ethers'
 
 // 1. Prepare your swap (e.g., USDC → WETH on mainnet)
-const { calldata, value } = SwapRouter.swapCallParameters(
-  trade,
-  swapOptions,
-  [
-    {
-      // Bridge configuration
-      depositor: userAddress,
-      recipient: userAddress,  // Recipient on destination chain
-      inputToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',  // WETH mainnet
-      outputToken: '0x4200000000000000000000000000000000000006',   // WETH optimism
-      inputAmount: BigNumber.from('1000000000000000000'),  // 1 WETH
-      outputAmount: BigNumber.from('990000000000000000'),  // 0.99 WETH (with fees)
-      destinationChainId: 10,  // Optimism
-      exclusiveRelayer: '0x0000000000000000000000000000000000000000',
-      quoteTimestamp: Math.floor(Date.now() / 1000),
-      fillDeadline: Math.floor(Date.now() / 1000) + 3600,
-      exclusivityDeadline: 0,
-      message: '0x',
-      useNative: false,
-    }
-  ]
-)
+const { calldata, value } = SwapRouter.swapCallParameters(trade, swapOptions, [
+  {
+    // Bridge configuration
+    depositor: userAddress,
+    recipient: userAddress, // Recipient on destination chain
+    inputToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH mainnet
+    outputToken: '0x4200000000000000000000000000000000000006', // WETH optimism
+    inputAmount: BigNumber.from('1000000000000000000'), // 1 WETH
+    outputAmount: BigNumber.from('990000000000000000'), // 0.99 WETH (with fees)
+    destinationChainId: 10, // Optimism
+    exclusiveRelayer: '0x0000000000000000000000000000000000000000',
+    quoteTimestamp: Math.floor(Date.now() / 1000),
+    fillDeadline: Math.floor(Date.now() / 1000) + 3600,
+    exclusivityDeadline: 0,
+    message: '0x',
+    useNative: false,
+  },
+])
 ```
 
 ### Swap + Bridge Example
@@ -239,24 +251,24 @@ const { calldata, value } = SwapRouter.swapCallParameters(
 // Swap USDC to WETH, then bridge WETH to Optimism
 const bridgeParams = {
   depositor: userAddress,
-  recipient: userAddress,  // Can be different address on destination
+  recipient: userAddress, // Can be different address on destination
   inputToken: WETH_MAINNET,
   outputToken: WETH_OPTIMISM,
-  inputAmount: CONTRACT_BALANCE,  // Use entire swap output
+  inputAmount: CONTRACT_BALANCE, // Use entire swap output
   outputAmount: expectedOutputAmount,
   destinationChainId: 10,
   exclusiveRelayer: '0x0000000000000000000000000000000000000000',
   quoteTimestamp: Math.floor(Date.now() / 1000),
   fillDeadline: Math.floor(Date.now() / 1000) + 3600,
   exclusivityDeadline: 0,
-  message: '0x',  // Optional message to execute on destination
-  useNative: false,  // Set to true to bridge native ETH
+  message: '0x', // Optional message to execute on destination
+  useNative: false, // Set to true to bridge native ETH
 }
 
 const { calldata, value } = SwapRouter.swapCallParameters(
   trade,
   swapOptions,
-  [bridgeParams]  // Array of bridge operations
+  [bridgeParams] // Array of bridge operations
 )
 ```
 
@@ -269,7 +281,7 @@ import { CONTRACT_BALANCE } from '@uniswap/universal-router-sdk'
 
 const bridgeParams = {
   // ... other params
-  inputAmount: CONTRACT_BALANCE,  // Bridge entire balance after swap
+  inputAmount: CONTRACT_BALANCE, // Bridge entire balance after swap
   // ... other params
 }
 ```
@@ -279,28 +291,24 @@ const bridgeParams = {
 You can perform multiple bridge operations after a swap:
 
 ```typescript
-const { calldata, value } = SwapRouter.swapCallParameters(
-  trade,
-  swapOptions,
-  [
-    {
-      // Bridge 50% to Optimism
-      inputToken: WETH_MAINNET,
-      outputToken: WETH_OPTIMISM,
-      inputAmount: BigNumber.from('500000000000000000'),
-      destinationChainId: 10,
-      // ... other params
-    },
-    {
-      // Bridge remaining USDC to Arbitrum
-      inputToken: USDC_MAINNET,
-      outputToken: USDC_ARBITRUM,
-      inputAmount: CONTRACT_BALANCE,
-      destinationChainId: 42161,
-      // ... other params
-    }
-  ]
-)
+const { calldata, value } = SwapRouter.swapCallParameters(trade, swapOptions, [
+  {
+    // Bridge 50% to Optimism
+    inputToken: WETH_MAINNET,
+    outputToken: WETH_OPTIMISM,
+    inputAmount: BigNumber.from('500000000000000000'),
+    destinationChainId: 10,
+    // ... other params
+  },
+  {
+    // Bridge remaining USDC to Arbitrum
+    inputToken: USDC_MAINNET,
+    outputToken: USDC_ARBITRUM,
+    inputAmount: CONTRACT_BALANCE,
+    destinationChainId: 42161,
+    // ... other params
+  },
+])
 ```
 
 ### Native ETH Bridging
@@ -309,9 +317,9 @@ To bridge native ETH instead of WETH:
 
 ```typescript
 const bridgeParams = {
-  inputToken: WETH_ADDRESS,  // Must be WETH address
+  inputToken: WETH_ADDRESS, // Must be WETH address
   outputToken: WETH_ON_DESTINATION,
-  useNative: true,  // Bridge as native ETH
+  useNative: true, // Bridge as native ETH
   // ... other params
 }
 ```

package/dist/{entities → cjs/src/entities}/Command.d.ts

@@ -1,12 +1,12 @@
-import { RoutePlanner } from '../utils/routerCommands';
-export declare type TradeConfig = {
-    allowRevert: boolean;
-};
-export declare enum RouterActionType {
-    UniswapTrade = "UniswapTrade",
-    UnwrapWETH = "UnwrapWETH"
-}
-export interface Command {
-    tradeType: RouterActionType;
-    encode(planner: RoutePlanner, config: TradeConfig): void;
-}
+import { RoutePlanner } from '../utils/routerCommands';
+export type TradeConfig = {
+    allowRevert: boolean;
+};
+export declare enum RouterActionType {
+    UniswapTrade = "UniswapTrade",
+    UnwrapWETH = "UnwrapWETH"
+}
+export interface Command {
+    tradeType: RouterActionType;
+    encode(planner: RoutePlanner, config: TradeConfig): void;
+}

package/dist/cjs/src/entities/Command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterActionType = void 0;
+var RouterActionType;
+(function (RouterActionType) {
+    RouterActionType["UniswapTrade"] = "UniswapTrade";
+    RouterActionType["UnwrapWETH"] = "UnwrapWETH";
+})(RouterActionType = exports.RouterActionType || (exports.RouterActionType = {}));
+//# sourceMappingURL=Command.js.map

package/dist/cjs/src/entities/Command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Command.js","sourceRoot":"","sources":["../../../../src/entities/Command.ts"],"names":[],"mappings":";;;AAMA,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,iDAA6B,CAAA;IAC7B,6CAAyB,CAAA;AAC3B,CAAC,EAHW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAG3B"}

package/dist/{entities → cjs/src/entities}/actions/across.d.ts

@@ -1,21 +1,21 @@
-import { BigNumberish } from 'ethers';
-/**
- * Parameters for Across V4 Deposit V3 command
- * Used for cross-chain bridging via Across Protocol V3 SpokePool
- */
-export declare type AcrossV4DepositV3Params = {
-    depositor: string;
-    recipient: string;
-    inputToken: string;
-    outputToken: string;
-    inputAmount: BigNumberish;
-    outputAmount: BigNumberish;
-    destinationChainId: number;
-    exclusiveRelayer: string;
-    quoteTimestamp: number;
-    fillDeadline: number;
-    exclusivityDeadline: number;
-    message: string;
-    useNative: boolean;
-};
-export { CONTRACT_BALANCE } from '../../utils/constants';
+import { BigNumberish } from 'ethers';
+/**
+ * Parameters for Across V4 Deposit V3 command
+ * Used for cross-chain bridging via Across Protocol V3 SpokePool
+ */
+export type AcrossV4DepositV3Params = {
+    depositor: string;
+    recipient: string;
+    inputToken: string;
+    outputToken: string;
+    inputAmount: BigNumberish;
+    outputAmount: BigNumberish;
+    destinationChainId: number;
+    exclusiveRelayer: string;
+    quoteTimestamp: number;
+    fillDeadline: number;
+    exclusivityDeadline: number;
+    message: string;
+    useNative: boolean;
+};
+export { CONTRACT_BALANCE } from '../../utils/constants';

package/dist/cjs/src/entities/actions/across.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_BALANCE = void 0;
+// Export CONTRACT_BALANCE constant for convenience
+var constants_1 = require("../../utils/constants");
+Object.defineProperty(exports, "CONTRACT_BALANCE", { enumerable: true, get: function () { return constants_1.CONTRACT_BALANCE; } });
+//# sourceMappingURL=across.js.map

package/dist/cjs/src/entities/actions/across.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"across.js","sourceRoot":"","sources":["../../../../../src/entities/actions/across.ts"],"names":[],"mappings":";;;AAsBA,mDAAmD;AACnD,mDAAwD;AAA/C,6GAAA,gBAAgB,OAAA"}

package/dist/{entities → cjs/src/entities}/actions/index.d.ts

@@ -1,3 +1,3 @@
-export * from './uniswap';
-export * from './unwrapWETH';
-export * from './across';
+export * from './uniswap';
+export * from './unwrapWETH';
+export * from './across';

package/dist/cjs/src/entities/actions/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./uniswap"), exports);
+tslib_1.__exportStar(require("./unwrapWETH"), exports);
+tslib_1.__exportStar(require("./across"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/src/entities/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/entities/actions/index.ts"],"names":[],"mappings":";;;AAAA,oDAAyB;AACzB,uDAA4B;AAC5B,mDAAwB"}

package/dist/{entities → cjs/src/entities}/actions/uniswap.d.ts

@@ -1,39 +1,38 @@
-import { RoutePlanner } from '../../utils/routerCommands';
-import { URVersion } from '@uniswap/v4-sdk';
-import { Trade as RouterTrade, SwapOptions as RouterSwapOptions } from '@uniswap/router-sdk';
-import { Permit2Permit } from '../../utils/inputTokens';
-import { Currency, TradeType } from '@uniswap/sdk-core';
-import { Command, RouterActionType, TradeConfig } from '../Command';
-import { BigNumber, BigNumberish } from 'ethers';
-export declare type FlatFeeOptions = {
-    amount: BigNumberish;
-    recipient: string;
-};
-export declare enum TokenTransferMode {
-    Permit2 = "Permit2",
-    ApproveProxy = "ApproveProxy"
-}
-export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
-    useRouterBalance?: boolean;
-    inputTokenPermit?: Permit2Permit;
-    flatFee?: FlatFeeOptions;
-    safeMode?: boolean;
-    maxHopSlippage?: BigNumber[];
-    urVersion?: URVersion;
-    tokenTransferMode?: TokenTransferMode;
-    chainId?: number;
-};
-export declare class UniswapTrade implements Command {
-    trade: RouterTrade<Currency, Currency, TradeType>;
-    options: SwapOptions;
-    readonly tradeType: RouterActionType;
-    readonly payerIsUser: boolean;
-    constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
-    get isAllV4(): boolean;
-    get inputRequiresWrap(): boolean;
-    get inputRequiresUnwrap(): boolean;
-    get outputRequiresWrap(): boolean;
-    get outputRequiresUnwrap(): boolean;
-    get outputRequiresTransition(): boolean;
-    encode(planner: RoutePlanner, _config: TradeConfig): void;
-}
+import { RoutePlanner } from '../../utils/routerCommands';
+import { URVersion } from '@uniswap/v4-sdk';
+import { Trade as RouterTrade, SwapOptions as RouterSwapOptions } from '@uniswap/router-sdk';
+import { Permit2Permit } from '../../utils/inputTokens';
+import { Currency, TradeType } from '@uniswap/sdk-core';
+import { Command, RouterActionType, TradeConfig } from '../Command';
+import { BigNumberish } from 'ethers';
+export type FlatFeeOptions = {
+    amount: BigNumberish;
+    recipient: string;
+};
+export declare enum TokenTransferMode {
+    Permit2 = "Permit2",
+    ApproveProxy = "ApproveProxy"
+}
+export type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
+    useRouterBalance?: boolean;
+    inputTokenPermit?: Permit2Permit;
+    flatFee?: FlatFeeOptions;
+    safeMode?: boolean;
+    urVersion?: URVersion;
+    tokenTransferMode?: TokenTransferMode;
+    chainId?: number;
+};
+export declare class UniswapTrade implements Command {
+    trade: RouterTrade<Currency, Currency, TradeType>;
+    options: SwapOptions;
+    readonly tradeType: RouterActionType;
+    readonly payerIsUser: boolean;
+    constructor(trade: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions);
+    get isAllV4(): boolean;
+    get inputRequiresWrap(): boolean;
+    get inputRequiresUnwrap(): boolean;
+    get outputRequiresWrap(): boolean;
+    get outputRequiresUnwrap(): boolean;
+    get outputRequiresTransition(): boolean;
+    encode(planner: RoutePlanner, _config: TradeConfig): void;
+}