@uniswap/universal-router-sdk 4.34.2 → 4.35.0

package/dist/esm/src/utils/routerTradeAdapter.js

@@ -0,0 +1,134 @@
+import { MixedRouteSDK, Trade as RouterTrade } from '@uniswap/router-sdk';
+import { CurrencyAmount, Ether, Token } from '@uniswap/sdk-core';
+import { Pair, Route as V2Route } from '@uniswap/v2-sdk';
+import { Pool as V3Pool, Route as V3Route } from '@uniswap/v3-sdk';
+import { Pool as V4Pool, Route as V4Route } from '@uniswap/v4-sdk';
+import { BigNumber } from 'ethers';
+import { ETH_ADDRESS, E_ETH_ADDRESS } from './constants';
+export var PoolType;
+(function (PoolType) {
+    PoolType["V2Pool"] = "v2-pool";
+    PoolType["V3Pool"] = "v3-pool";
+    PoolType["V4Pool"] = "v4-pool";
+})(PoolType || (PoolType = {}));
+export const isNativeCurrency = (address) => address.toLowerCase() === ETH_ADDRESS.toLowerCase() || address.toLowerCase() === E_ETH_ADDRESS.toLowerCase();
+// Helper class to convert routing-specific quote entities to RouterTrade entities
+// the returned RouterTrade can then be used to build the UniswapTrade entity in this package
+export class RouterTradeAdapter {
+    // Generate a RouterTrade using fields from a classic quote response
+    static fromClassicQuote(quote) {
+        const { route, tokenIn, tokenOut } = quote;
+        if (!route)
+            throw new Error('Expected route to be present');
+        if (!route.length)
+            throw new Error('Expected there to be at least one route');
+        if (route.some((r) => !r.length))
+            throw new Error('Expected all routes to have at least one pool');
+        const firstRoute = route[0];
+        const tokenInData = firstRoute[0].tokenIn;
+        const tokenOutData = firstRoute[firstRoute.length - 1].tokenOut;
+        if (!tokenInData || !tokenOutData)
+            throw new Error('Expected both tokenIn and tokenOut to be present');
+        if (tokenInData.chainId !== tokenOutData.chainId)
+            throw new Error('Expected tokenIn and tokenOut to be have same chainId');
+        const parsedCurrencyIn = RouterTradeAdapter.toCurrency(isNativeCurrency(tokenIn), tokenInData);
+        const parsedCurrencyOut = RouterTradeAdapter.toCurrency(isNativeCurrency(tokenOut), tokenOutData);
+        const typedRoutes = route.map((subRoute) => {
+            const rawAmountIn = subRoute[0].amountIn;
+            const rawAmountOut = subRoute[subRoute.length - 1].amountOut;
+            if (!rawAmountIn || !rawAmountOut) {
+                throw new Error('Expected both raw amountIn and raw amountOut to be present');
+            }
+            const inputAmount = CurrencyAmount.fromRawAmount(parsedCurrencyIn, rawAmountIn);
+            const outputAmount = CurrencyAmount.fromRawAmount(parsedCurrencyOut, rawAmountOut);
+            const isOnlyV2 = RouterTradeAdapter.isVersionedRoute(PoolType.V2Pool, subRoute);
+            const isOnlyV3 = RouterTradeAdapter.isVersionedRoute(PoolType.V3Pool, subRoute);
+            const isOnlyV4 = RouterTradeAdapter.isVersionedRoute(PoolType.V4Pool, subRoute);
+            return {
+                routev4: isOnlyV4
+                    ? new V4Route(subRoute.map(RouterTradeAdapter.toV4Pool), parsedCurrencyIn, parsedCurrencyOut)
+                    : null,
+                routev3: isOnlyV3
+                    ? new V3Route(subRoute.map(RouterTradeAdapter.toV3Pool), parsedCurrencyIn, parsedCurrencyOut)
+                    : null,
+                routev2: isOnlyV2
+                    ? new V2Route(subRoute.map(RouterTradeAdapter.toPair), parsedCurrencyIn, parsedCurrencyOut)
+                    : null,
+                mixedRoute: !isOnlyV4 && !isOnlyV3 && !isOnlyV2
+                    ? new MixedRouteSDK(subRoute.map(RouterTradeAdapter.toPoolOrPair), parsedCurrencyIn, parsedCurrencyOut)
+                    : null,
+                inputAmount,
+                outputAmount,
+            };
+        });
+        return new RouterTrade({
+            v2Routes: typedRoutes
+                .filter((route) => route.routev2)
+                .map((route) => ({
+                routev2: route.routev2,
+                inputAmount: route.inputAmount,
+                outputAmount: route.outputAmount,
+            })),
+            v3Routes: typedRoutes
+                .filter((route) => route.routev3)
+                .map((route) => ({
+                routev3: route.routev3,
+                inputAmount: route.inputAmount,
+                outputAmount: route.outputAmount,
+            })),
+            v4Routes: typedRoutes
+                .filter((route) => route.routev4)
+                .map((route) => ({
+                routev4: route.routev4,
+                inputAmount: route.inputAmount,
+                outputAmount: route.outputAmount,
+            })),
+            mixedRoutes: typedRoutes
+                .filter((route) => route.mixedRoute)
+                .map((route) => ({
+                mixedRoute: route.mixedRoute,
+                inputAmount: route.inputAmount,
+                outputAmount: route.outputAmount,
+            })),
+            tradeType: quote.tradeType,
+        });
+    }
+    static toCurrency(isNative, token) {
+        if (isNative) {
+            return Ether.onChain(token.chainId);
+        }
+        return this.toToken(token);
+    }
+    static toToken(token) {
+        const { chainId, address, decimals, symbol, buyFeeBps, sellFeeBps } = token;
+        return new Token(chainId, address, parseInt(decimals.toString()), symbol, 
+        /* name */ undefined, false, buyFeeBps ? BigNumber.from(buyFeeBps) : undefined, sellFeeBps ? BigNumber.from(sellFeeBps) : undefined);
+    }
+    static toV3Pool({ fee, sqrtRatioX96, liquidity, tickCurrent, tokenIn, tokenOut }) {
+        return new V3Pool(RouterTradeAdapter.toToken(tokenIn), RouterTradeAdapter.toToken(tokenOut), parseInt(fee), sqrtRatioX96, liquidity, parseInt(tickCurrent));
+    }
+    static toV4Pool(pool) {
+        const parsedCurrencyIn = RouterTradeAdapter.toCurrency(isNativeCurrency(pool.tokenIn.address), pool.tokenIn);
+        const parsedCurrencyOut = RouterTradeAdapter.toCurrency(isNativeCurrency(pool.tokenOut.address), pool.tokenOut);
+        return new V4Pool(parsedCurrencyIn, parsedCurrencyOut, parseInt(pool.fee), parseInt(pool.tickSpacing), pool.hooks, pool.sqrtRatioX96, pool.liquidity, parseInt(pool.tickCurrent));
+    }
+    static isVersionedRoute(type, route) {
+        return route.every((pool) => pool.type === type);
+    }
+}
+RouterTradeAdapter.toPoolOrPair = (pool) => {
+    switch (pool.type) {
+        case PoolType.V4Pool:
+            return RouterTradeAdapter.toV4Pool(pool);
+        case PoolType.V3Pool:
+            return RouterTradeAdapter.toV3Pool(pool);
+        case PoolType.V2Pool:
+            return RouterTradeAdapter.toPair(pool);
+        default:
+            throw new Error('Invalid pool type');
+    }
+};
+RouterTradeAdapter.toPair = ({ reserve0, reserve1 }) => {
+    return new Pair(CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve0.token), reserve0.quotient), CurrencyAmount.fromRawAmount(RouterTradeAdapter.toToken(reserve1.token), reserve1.quotient));
+};
+//# sourceMappingURL=routerTradeAdapter.js.map

package/dist/esm/src/utils/routerTradeAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routerTradeAdapter.js","sourceRoot":"","sources":["../../../../src/utils/routerTradeAdapter.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,12 @@
+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/types/src/entities/actions/across.d.ts

@@ -0,0 +1,21 @@
+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/types/src/entities/actions/index.d.ts

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

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

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

package/dist/types/src/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/types/src/entities/index.d.ts

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

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

@@ -0,0 +1,12 @@
+export { SwapRouter } from './swapRouter';
+export type { MigrateV3ToV4Options, SignedRouteOptions, EIP712Payload } 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, SWAP_PROXY_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';
+export { NONCE_SKIP_CHECK, generateNonce, EXECUTE_SIGNED_TYPES, getUniversalRouterDomain } from './utils/eip712';
+export { URVersion, isAtLeastV2_1_1 } from '@uniswap/v4-sdk';

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

@@ -0,0 +1,87 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumber, 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';
+import { AcrossV4DepositV3Params } from './entities/actions/across';
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
+export type SwapRouterConfig = {
+    sender?: string;
+    deadline?: BigNumberish;
+};
+export type SignedRouteOptions = {
+    intent: string;
+    data: string;
+    sender: string;
+    nonce?: string;
+};
+export type EIP712Payload = {
+    domain: TypedDataDomain;
+    types: Record<string, TypedDataField[]>;
+    value: {
+        commands: string;
+        inputs: string[];
+        intent: string;
+        data: string;
+        sender: string;
+        nonce: string;
+        deadline: string;
+    };
+};
+export interface MigrateV3ToV4Options {
+    inputPosition: V3Position;
+    outputPosition: V4Position;
+    v3RemoveLiquidityOptions: V3RemoveLiquidityOptions;
+    v4AddLiquidityOptions: V4AddLiquidityOptions;
+}
+export declare abstract class SwapRouter {
+    static INTERFACE: Interface;
+    static PROXY_INTERFACE: Interface;
+    static swapCallParameters(trades: RouterTrade<Currency, Currency, TradeType>, options: SwapOptions, bridgeOptions?: AcrossV4DepositV3Params[]): MethodParameters;
+    /**
+     * Generate EIP712 payload for signed execution (no signing performed)
+     * Decodes existing execute() calldata and prepares it for signing
+     *
+     * @param calldata The calldata from swapCallParameters() or similar
+     * @param signedOptions Options for signed execution (intent, data, sender, nonce)
+     * @param deadline The deadline timestamp
+     * @param chainId The chain ID
+     * @param routerAddress The Universal Router contract address
+     * @returns EIP712 payload ready to be signed externally
+     */
+    static getExecuteSignedPayload(calldata: string, signedOptions: SignedRouteOptions, deadline: BigNumberish, chainId: number, routerAddress: string): EIP712Payload;
+    /**
+     * Encode executeSigned() call with signature
+     *
+     * @param calldata The original calldata from swapCallParameters()
+     * @param signature The signature obtained from external signing
+     * @param signedOptions The same options used in getExecuteSignedPayload()
+     * @param deadline The deadline timestamp
+     * @param nativeCurrencyValue The native currency value (ETH) to send
+     * @returns Method parameters for executeSigned()
+     */
+    static encodeExecuteSigned(calldata: string, signature: string, signedOptions: SignedRouteOptions, deadline: BigNumberish, nativeCurrencyValue?: BigNumber): 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;
+    /**
+     * Encodes a planned route into calldata targeting the SwapProxy contract.
+     * The proxy pulls ERC20 tokens from the user into the UR, then executes commands.
+     */
+    private static encodeProxyPlan;
+}

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

@@ -0,0 +1,34 @@
+import { Interface } from '@ethersproject/abi';
+import { CommandType, CommandDefinition } from '../utils/routerCommands';
+export type Param = {
+    readonly name: string;
+    readonly value: any;
+};
+export type UniversalRouterCommand = {
+    readonly commandName: string;
+    readonly commandType: CommandType;
+    readonly params: readonly Param[];
+};
+export type UniversalRouterCall = {
+    readonly commands: readonly UniversalRouterCommand[];
+};
+export type V3PathItem = {
+    readonly tokenIn: string;
+    readonly tokenOut: string;
+    readonly fee: number;
+};
+export interface CommandsDefinition {
+    [key: number]: CommandDefinition;
+}
+export declare abstract class CommandParser {
+    static INTERFACE: Interface;
+    static parseCalldata(calldata: string): UniversalRouterCall;
+}
+export declare class GenericCommandParser {
+    private readonly commandDefinition;
+    constructor(commandDefinition: CommandsDefinition);
+    parse(commands: string, inputs: string[]): UniversalRouterCall;
+    private static getCommands;
+}
+export declare function parseV3PathExactIn(path: string): readonly V3PathItem[];
+export declare function parseV3PathExactOut(path: string): readonly V3PathItem[];

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

@@ -0,0 +1,33 @@
+import { BigNumber } from 'ethers';
+export declare enum UniversalRouterVersion {
+    V1_2 = "1.2",
+    V2_0 = "2.0",
+    V2_1_1 = "2.1.1"
+}
+export type RouterConfig = {
+    address: string;
+    creationBlock: number;
+};
+type ChainConfig = {
+    weth: string;
+    routerConfigs: {
+        [key in UniversalRouterVersion]?: RouterConfig;
+    };
+    swapProxy?: string;
+};
+export declare const CHAIN_CONFIGS: {
+    [key: number]: ChainConfig;
+};
+export declare const UNIVERSAL_ROUTER_ADDRESS: (version: UniversalRouterVersion, chainId: number) => string;
+export declare const SWAP_PROXY_ADDRESS: (chainId: number) => string;
+export declare const UNIVERSAL_ROUTER_CREATION_BLOCK: (version: UniversalRouterVersion, chainId: number) => number;
+export declare const WETH_ADDRESS: (chainId: number) => string;
+export declare const CONTRACT_BALANCE: BigNumber;
+export declare const ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const E_ETH_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const MAX_UINT256: BigNumber;
+export declare const MAX_UINT160: BigNumber;
+export declare const SENDER_AS_RECIPIENT = "0x0000000000000000000000000000000000000001";
+export declare const ROUTER_AS_RECIPIENT = "0x0000000000000000000000000000000000000002";
+export {};

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

@@ -0,0 +1,17 @@
+import { TypedDataDomain, TypedDataField } from '@ethersproject/abstract-signer';
+export declare const EIP712_DOMAIN_NAME = "UniversalRouter";
+export declare const EIP712_DOMAIN_VERSION = "2";
+export declare const EXECUTE_SIGNED_TYPES: Record<string, TypedDataField[]>;
+/**
+ * Generate EIP712 domain for Universal Router
+ */
+export declare function getUniversalRouterDomain(chainId: number, verifyingContract: string): TypedDataDomain;
+/**
+ * Generate a random nonce for signed execution
+ * Uses ethers.utils.randomBytes for secure randomness
+ */
+export declare function generateNonce(): string;
+/**
+ * Sentinel value to skip nonce checking (allows signature replay)
+ */
+export declare const NONCE_SKIP_CHECK: string;

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

@@ -0,0 +1,2 @@
+import { Currency } from '@uniswap/sdk-core';
+export declare function getCurrencyAddress(currency: Currency): string;

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

@@ -0,0 +1,23 @@
+import { BigintIsh } from '@uniswap/sdk-core';
+import { NFTPermitOptions } from '@uniswap/v3-sdk';
+import { PermitSingle } from '@uniswap/permit2-sdk';
+import { RoutePlanner } from './routerCommands';
+export interface Permit2Permit extends PermitSingle {
+    signature: string;
+}
+export type ApproveProtocol = {
+    token: string;
+    protocol: string;
+};
+export type Permit2TransferFrom = {
+    token: string;
+    amount: string;
+    recipient?: string;
+};
+export type InputTokenOptions = {
+    permit2Permit?: Permit2Permit;
+    permit2TransferFrom?: Permit2TransferFrom;
+};
+export declare function encodePermit(planner: RoutePlanner, permit2: Permit2Permit): void;
+export declare function encodeV3PositionPermit(planner: RoutePlanner, permit: NFTPermitOptions, tokenId: BigintIsh): void;
+export declare function encodeInputTokenOptions(planner: RoutePlanner, options: InputTokenOptions): void;

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

@@ -0,0 +1,7 @@
+import { BigNumber } from 'ethers';
+import JSBI from 'jsbi';
+import { Percent } from '@uniswap/sdk-core';
+export declare function expandTo18DecimalsBN(n: number): BigNumber;
+export declare function expandTo18Decimals(n: number): JSBI;
+export declare function encodeFeeBips(fee: Percent): string;
+export declare function encodeFee1e18(fee: Percent): string;

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

@@ -0,0 +1,3 @@
+import { Currency } from '@uniswap/sdk-core';
+import { TPool } from '@uniswap/router-sdk';
+export declare function getPathCurrency(currency: Currency, pool: TPool): Currency;

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

@@ -0,0 +1,77 @@
+import { URVersion } from '@uniswap/v4-sdk';
+import { AcrossV4DepositV3Params } from '../entities/actions/across';
+/**
+ * CommandTypes
+ * @description Flags that modify a command's execution
+ * @enum {number}
+ */
+export declare enum CommandType {
+    V3_SWAP_EXACT_IN = 0,
+    V3_SWAP_EXACT_OUT = 1,
+    PERMIT2_TRANSFER_FROM = 2,
+    PERMIT2_PERMIT_BATCH = 3,
+    SWEEP = 4,
+    TRANSFER = 5,
+    PAY_PORTION = 6,
+    PAY_PORTION_FULL_PRECISION = 7,
+    V2_SWAP_EXACT_IN = 8,
+    V2_SWAP_EXACT_OUT = 9,
+    PERMIT2_PERMIT = 10,
+    WRAP_ETH = 11,
+    UNWRAP_WETH = 12,
+    PERMIT2_TRANSFER_FROM_BATCH = 13,
+    BALANCE_CHECK_ERC20 = 14,
+    V4_SWAP = 16,
+    V3_POSITION_MANAGER_PERMIT = 17,
+    V3_POSITION_MANAGER_CALL = 18,
+    V4_INITIALIZE_POOL = 19,
+    V4_POSITION_MANAGER_CALL = 20,
+    EXECUTE_SUB_PLAN = 33,
+    ACROSS_V4_DEPOSIT_V3 = 64
+}
+export declare enum Subparser {
+    V3PathExactIn = 0,
+    V3PathExactOut = 1
+}
+export declare enum Parser {
+    Abi = 0,
+    V4Actions = 1,
+    V3Actions = 2
+}
+export type ParamType = {
+    readonly name: string;
+    readonly type: string;
+    readonly subparser?: Subparser;
+};
+export type CommandDefinition = {
+    parser: Parser.Abi;
+    params: ParamType[];
+} | {
+    parser: Parser.V4Actions;
+} | {
+    parser: Parser.V3Actions;
+};
+export declare const COMMAND_DEFINITION: {
+    [key in CommandType]: CommandDefinition;
+};
+export declare const V2V3_SWAP_COMMANDS_V2_1_1: {
+    [key: number]: CommandDefinition;
+};
+export declare class RoutePlanner {
+    commands: string;
+    inputs: string[];
+    constructor();
+    addSubPlan(subplan: RoutePlanner): RoutePlanner;
+    addCommand(type: CommandType, parameters: any[], allowRevert?: boolean, urVersion?: URVersion): RoutePlanner;
+    /**
+     * Add Across bridge deposit command for cross-chain bridging
+     * @param params AcrossV4DepositV3Params containing bridge parameters
+     * @returns RoutePlanner instance for chaining
+     */
+    addAcrossBridge(params: AcrossV4DepositV3Params): RoutePlanner;
+}
+export type RouterCommand = {
+    type: CommandType;
+    encodedInput: string;
+};
+export declare function createCommand(type: CommandType, parameters: any[], urVersion?: URVersion): RouterCommand;

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

@@ -0,0 +1,73 @@
+import { Trade as RouterTrade } from '@uniswap/router-sdk';
+import { Currency, TradeType } from '@uniswap/sdk-core';
+export type TokenInRoute = {
+    address: string;
+    chainId: number;
+    symbol: string;
+    decimals: string;
+    name?: string;
+    buyFeeBps?: string;
+    sellFeeBps?: string;
+};
+export declare enum PoolType {
+    V2Pool = "v2-pool",
+    V3Pool = "v3-pool",
+    V4Pool = "v4-pool"
+}
+export type V2Reserve = {
+    token: TokenInRoute;
+    quotient: string;
+};
+export type V2PoolInRoute = {
+    type: PoolType.V2Pool;
+    address?: string;
+    tokenIn: TokenInRoute;
+    tokenOut: TokenInRoute;
+    reserve0: V2Reserve;
+    reserve1: V2Reserve;
+    amountIn?: string;
+    amountOut?: string;
+};
+export type V3PoolInRoute = {
+    type: PoolType.V3Pool;
+    address?: string;
+    tokenIn: TokenInRoute;
+    tokenOut: TokenInRoute;
+    sqrtRatioX96: string;
+    liquidity: string;
+    tickCurrent: string;
+    fee: string;
+    amountIn?: string;
+    amountOut?: string;
+};
+export type V4PoolInRoute = {
+    type: PoolType.V4Pool;
+    address?: string;
+    tokenIn: TokenInRoute;
+    tokenOut: TokenInRoute;
+    fee: string;
+    tickSpacing: string;
+    hooks: string;
+    liquidity: string;
+    sqrtRatioX96: string;
+    tickCurrent: string;
+    amountIn?: string;
+    amountOut?: string;
+};
+export type PartialClassicQuote = {
+    tokenIn: string;
+    tokenOut: string;
+    tradeType: TradeType;
+    route: Array<(V4PoolInRoute | V3PoolInRoute | V2PoolInRoute)[]>;
+};
+export declare const isNativeCurrency: (address: string) => boolean;
+export declare class RouterTradeAdapter {
+    static fromClassicQuote(quote: PartialClassicQuote): RouterTrade<Currency, Currency, TradeType>;
+    private static toCurrency;
+    private static toPoolOrPair;
+    private static toToken;
+    private static toV3Pool;
+    private static toV4Pool;
+    private static toPair;
+    private static isVersionedRoute;
+}