@hskswap/universal_router_sdk 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# universal-router-sdk
+This SDK facilitates interactions with the contracts in [Universal Router](https://github.com/Uniswap/universal-router)
+
+## Usage
+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 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'
+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 })
+// Use the raw calldata and value returned to call into Universal Swap Router contracts
+const { calldata, value } = SwapRouter.swapCallParameters(routerTrade, options)
+```
+
+## Running this package
+Make sure you are running `node v18`
+Install dependencies and run typescript unit tests
+```bash
+yarn install
+yarn test:hardhat
+```
+
+Run forge integration tests
+```bash
+forge install
+yarn test:forge
+```

package/dist/entities/Command.d.ts

@@ -0,0 +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;
+}

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

@@ -0,0 +1,2 @@
+export * from './uniswap';
+export * from './unwrapWETH';

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

@@ -0,0 +1,39 @@
+import { RoutePlanner } from '../../utils/routerCommands';
+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 declare type FlatFeeOptions = {
+    amount: BigNumberish;
+    recipient: string;
+};
+export declare type SwapOptions = Omit<RouterSwapOptions, 'inputTokenPermit'> & {
+    useRouterBalance?: boolean;
+    inputTokenPermit?: Permit2Permit;
+    flatFee?: FlatFeeOptions;
+    safeMode?: boolean;
+};
+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;
+    /**
+     * Checks if any route in a split trade ends with an ETH-WETH pool.
+     *
+     * When a split trade has routes ending in ETH-WETH pools alongside routes ending in WETH,
+     * V4 swaps that are last in their route must TAKE WETH (not ETH) at the endfor consistency.
+     * This ensures all routes accumulate WETH, which can then be unwrapped together to ETH
+     * in a single operation at the end.
+     */
+    get shouldForceV4UnwrapForSplitNativeOutput(): boolean;
+    get inputRequiresWrap(): boolean;
+    get inputRequiresUnwrap(): boolean;
+    get outputRequiresWrap(): boolean;
+    get outputRequiresUnwrap(): boolean;
+    get outputRequiresTransition(): boolean;
+    encode(planner: RoutePlanner, _config: TradeConfig): void;
+}

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

@@ -0,0 +1,12 @@
+import { BigNumberish } from 'ethers';
+import { RoutePlanner } from '../../utils/routerCommands';
+import { Permit2Permit } from '../../utils/inputTokens';
+import { Command, RouterActionType, TradeConfig } from '../Command';
+export declare class UnwrapWETH implements Command {
+    readonly tradeType: RouterActionType;
+    readonly permit2Data?: Permit2Permit;
+    readonly wethAddress: string;
+    readonly amount: BigNumberish;
+    constructor(amount: BigNumberish, chainId: number, permit2?: Permit2Permit);
+    encode(planner: RoutePlanner, _: TradeConfig): void;
+}

package/dist/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './Command';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { SwapRouter } from './swapRouter';
+export type { MigrateV3ToV4Options } from './swapRouter';
+export * from './entities';
+export * from './utils/routerTradeAdapter';
+export { RoutePlanner, CommandType, COMMAND_DEFINITION, Parser, Subparser } from './utils/routerCommands';
+export type { CommandDefinition, ParamType } from './utils/routerCommands';
+export { UNIVERSAL_ROUTER_CREATION_BLOCK, UNIVERSAL_ROUTER_ADDRESS, ROUTER_AS_RECIPIENT, WETH_ADDRESS, UniversalRouterVersion, } from './utils/constants';
+export { CommandParser, GenericCommandParser } from './utils/commandParser';
+export type { UniversalRouterCommand, UniversalRouterCall, Param, CommandsDefinition } from './utils/commandParser';
+export type { Permit2Permit } from './utils/inputTokens';

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,37 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumberish } from 'ethers';
+import { MethodParameters, Position as V3Position, RemoveLiquidityOptions as V3RemoveLiquidityOptions } from '@uniswap/v3-sdk';
+import { Position as V4Position, AddLiquidityOptions as V4AddLiquidityOptions } from '@uniswap/v4-sdk';
+import { Trade as RouterTrade } from '@uniswap/router-sdk';
+import { Currency, TradeType } from '@uniswap/sdk-core';
+import { SwapOptions } from './entities/actions/uniswap';
+export declare type SwapRouterConfig = {
+    sender?: string;
+    deadline?: BigNumberish;
+};
+export interface MigrateV3ToV4Options {
+    inputPosition: V3Position;
+    outputPosition: V4Position;
+    v3RemoveLiquidityOptions: V3RemoveLiquidityOptions;
+    v4AddLiquidityOptions: V4AddLiquidityOptions;
+}
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    static swapCallParameters(trades: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions): MethodParameters;
+    /**
+     * Builds the call parameters for a migration from a V3 position to a V4 position.
+     * Some requirements of the parameters:
+     *   - v3RemoveLiquidityOptions.collectOptions.recipient must equal v4PositionManager
+     *   - v3RemoveLiquidityOptions.liquidityPercentage must be 100%
+     *   - input pool and output pool must have the same tokens
+     *   - V3 NFT must be approved, or valid inputV3NFTPermit must be provided with UR as spender
+     */
+    static migrateV3ToV4CallParameters(options: MigrateV3ToV4Options, positionManagerOverride?: string): 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;
+}

package/dist/test/forge/writeInterop.d.ts

@@ -0,0 +1,2 @@
+import { MethodParameters } from '@uniswap/v3-sdk';
+export declare function registerFixture(key: string, data: MethodParameters): void;

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

@@ -0,0 +1,5 @@
+export declare const FORGE_V4_POSITION_MANAGER = "0x2e234DAe75C793f67A35089C9d99245E1C58470b";
+export declare const FORGE_SENDER_ADDRESS = "0xcf03dd0a894ef79cb5b601a43c4b25e3ae4c67ed";
+export declare const TEST_RECIPIENT_ADDRESS = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+export declare const TEST_FEE_RECIPIENT_ADDRESS = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+export declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";

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,7 @@
+import { Wallet } from 'ethers';
+import { PermitSingle } from '@uniswap/permit2-sdk';
+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;
+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 { Trade as V4Trade } from '@uniswap/v4-sdk';
+import { SwapOptions } from '../../src';
+import { TradeType, Ether, Token, Currency } from '@uniswap/sdk-core';
+export declare const ETHER: Ether;
+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> | V4Trade<Currency, Currency, TradeType> | MixedRouteTrade<Currency, Currency, TradeType>)[]): RouterTrade<Currency, Currency, TradeType>;
+export {};