@fenine/universal-router-sdk 1.0.0

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

@@ -0,0 +1,130 @@
+import { BigNumber } from 'ethers';
+import invariant from 'tiny-invariant';
+import { TradeType } from '@fenine/sdk-core';
+import { TokenTransferMode } from '../entities/actions/uniswap';
+import { ROUTER_AS_RECIPIENT, SENDER_AS_RECIPIENT, UniversalRouterVersion, ZERO_ADDRESS } from './constants';
+// V3 path: 20-byte address + N × (3-byte fee + 20-byte address); minimum is 43 bytes (single hop, N=1)
+// Returns N or undefined if malformed
+function getV3HopCount(path) {
+    if (!path.startsWith('0x'))
+        return undefined;
+    const byteLength = (path.length - 2) / 2;
+    if (byteLength < 43)
+        return undefined;
+    const variableSegmentLength = byteLength - 20;
+    if (variableSegmentLength < 23 || variableSegmentLength % 23 !== 0)
+        return undefined;
+    return variableSegmentLength / 23;
+}
+function hasV4MinHopPriceX36(action) {
+    switch (action.action) {
+        case 'SWAP_EXACT_IN':
+        case 'SWAP_EXACT_OUT':
+        case 'SWAP_EXACT_IN_SINGLE':
+        case 'SWAP_EXACT_OUT_SINGLE':
+            return action.minHopPriceX36 !== undefined;
+        default:
+            return false;
+    }
+}
+function validateV4HopCounts(actions) {
+    for (const action of actions) {
+        switch (action.action) {
+            case 'SWAP_EXACT_IN':
+            case 'SWAP_EXACT_OUT':
+                invariant(!action.minHopPriceX36 || action.minHopPriceX36.length === action.path.length, 'V4_MIN_HOP_PRICE_X36_LENGTH_MISMATCH');
+                break;
+            default:
+                break;
+        }
+    }
+}
+function assertRouterRecipient(recipient) {
+    invariant(recipient === ROUTER_AS_RECIPIENT, 'STEP_RECIPIENT_MUST_BE_ROUTER');
+}
+function assertRouterActionRecipient(recipient) {
+    invariant(recipient === ROUTER_AS_RECIPIENT, 'V4_ACTION_RECIPIENT_MUST_BE_ROUTER');
+}
+// V4 actions that take a recipient must use router custody so the SDK's settlement sweeps see the funds
+function validateV4Recipients(actions) {
+    for (const action of actions) {
+        switch (action.action) {
+            case 'TAKE':
+            case 'TAKE_PORTION':
+                assertRouterActionRecipient(action.recipient);
+                break;
+            default:
+                break;
+        }
+    }
+}
+export function validateEncodeSwaps(spec, swapSteps) {
+    var _a, _b, _c, _d;
+    invariant(swapSteps.length > 0, 'EMPTY_SWAP_STEPS');
+    const amountCurrency = spec.routing.amount.currency.wrapped;
+    const quoteCurrency = spec.routing.quote.currency.wrapped;
+    const inputCurrency = spec.routing.inputToken.wrapped;
+    const outputCurrency = spec.routing.outputToken.wrapped;
+    invariant(!spec.slippageTolerance.lessThan(0), 'SLIPPAGE_TOLERANCE');
+    invariant(spec.recipient !== ZERO_ADDRESS, 'RECIPIENT_CANNOT_BE_ZERO');
+    invariant(spec.recipient !== ROUTER_AS_RECIPIENT, 'RECIPIENT_CANNOT_BE_ROUTER');
+    // routing.amount is on the exact side of the trade; routing.quote is on the slippage side
+    if (spec.tradeType === TradeType.EXACT_INPUT) {
+        invariant(amountCurrency.equals(inputCurrency), 'INVALID_ROUTING_AMOUNT_CURRENCY');
+        invariant(quoteCurrency.equals(outputCurrency), 'INVALID_ROUTING_QUOTE_CURRENCY');
+    }
+    else {
+        invariant(amountCurrency.equals(outputCurrency), 'INVALID_ROUTING_AMOUNT_CURRENCY');
+        invariant(quoteCurrency.equals(inputCurrency), 'INVALID_ROUTING_QUOTE_CURRENCY');
+    }
+    // ApproveProxy ingress lives upstream in the proxy contract: needs chain id, ERC20 input, no permit2, explicit recipient
+    if (spec.tokenTransferMode === TokenTransferMode.ApproveProxy) {
+        invariant(!!spec.chainId, 'PROXY_MISSING_CHAIN_ID');
+        invariant(!spec.routing.inputToken.isNative, 'PROXY_NATIVE_INPUT');
+        invariant(!spec.permit, 'PROXY_PERMIT_CONFLICT');
+        invariant(spec.recipient !== SENDER_AS_RECIPIENT, 'PROXY_EXPLICIT_RECIPIENT_REQUIRED');
+    }
+    // permit2 is ERC20-only; native input pays via msg.value
+    invariant(!(spec.routing.inputToken.isNative && spec.permit), 'NATIVE_INPUT_PERMIT');
+    // portion fees pair with exact-input (% of variable output); flat fees pair with exact-output (fixed deduction from the target)
+    invariant(!(((_a = spec.fee) === null || _a === void 0 ? void 0 : _a.kind) === 'portion' && spec.tradeType !== TradeType.EXACT_INPUT), 'INVALID_PORTION_FEE_TRADE_TYPE');
+    invariant(!(((_b = spec.fee) === null || _b === void 0 ? void 0 : _b.kind) === 'flat' && spec.tradeType !== TradeType.EXACT_OUTPUT), 'INVALID_FLAT_FEE_TRADE_TYPE');
+    invariant(!(((_c = spec.fee) === null || _c === void 0 ? void 0 : _c.kind) === 'flat' &&
+        BigNumber.from(spec.fee.amount).gt(BigNumber.from(spec.routing.amount.quotient.toString()))), 'FLAT_FEE_GT_AMOUNT');
+    // v2.0 PAY_PORTION takes whole bps; fractional bps need >=v2.1.1's PAY_PORTION_FULL_PRECISION
+    invariant(!(((_d = spec.fee) === null || _d === void 0 ? void 0 : _d.kind) === 'portion' &&
+        spec.urVersion === UniversalRouterVersion.V2_0 &&
+        !spec.fee.fee.multiply(10000).remainder.equalTo(0)), 'FRACTIONAL_BPS_PORTION_FEE_UNSUPPORTED_ON_V2_0');
+    // per-step: capability-gate by UR version, recipients must be router custody, per-hop arrays must match hop counts
+    for (const step of swapSteps) {
+        if (spec.urVersion === UniversalRouterVersion.V2_0) {
+            invariant(!('minHopPriceX36' in step) || step.minHopPriceX36 === undefined, 'MIN_HOP_PRICE_X36_UNSUPPORTED_ON_V2_0');
+            invariant(!(step.type === 'V4_SWAP' && step.v4Actions.some(hasV4MinHopPriceX36)), 'MIN_HOP_PRICE_X36_UNSUPPORTED_ON_V2_0');
+        }
+        switch (step.type) {
+            case 'V2_SWAP_EXACT_IN':
+            case 'V2_SWAP_EXACT_OUT':
+                assertRouterRecipient(step.recipient);
+                invariant(!step.minHopPriceX36 || step.minHopPriceX36.length === step.path.length - 1, 'V2_MIN_HOP_PRICE_X36_LENGTH_MISMATCH');
+                break;
+            case 'V3_SWAP_EXACT_IN':
+            case 'V3_SWAP_EXACT_OUT': {
+                assertRouterRecipient(step.recipient);
+                const hopCount = getV3HopCount(step.path);
+                invariant(hopCount === undefined || !step.minHopPriceX36 || step.minHopPriceX36.length === hopCount, 'V3_MIN_HOP_PRICE_X36_LENGTH_MISMATCH');
+                break;
+            }
+            case 'WRAP_ETH':
+            case 'UNWRAP_WETH':
+                assertRouterRecipient(step.recipient);
+                break;
+            case 'V4_SWAP':
+                validateV4HopCounts(step.v4Actions);
+                validateV4Recipients(step.v4Actions);
+                break;
+            default:
+                break;
+        }
+    }
+}
+//# sourceMappingURL=validateEncodeSwaps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateEncodeSwaps.js","sourceRoot":"","sources":["../../../../src/utils/validateEncodeSwaps.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 { Trade as RouterTrade, SwapOptions as RouterSwapOptions } from '@uniswap/router-sdk';
+import { Permit2Permit } from '../../utils/inputTokens';
+import { Currency, TradeType } from '@fenine/sdk-core';
+import { Command, RouterActionType, TradeConfig } from '../Command';
+import { UniversalRouterVersion } from '../../utils/constants';
+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?: UniversalRouterVersion;
+    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,14 @@
+export { SwapRouter } from './swapRouter';
+export type { MigrateV3ToV4Options, SignedRouteOptions, EIP712Payload } from './swapRouter';
+export * from './types/encodeSwaps';
+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, isAtLeastV2_1_1, } 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 { normalizeEncodeSwapsSpec } from './utils/normalizeEncodeSwapsSpec';
+export { validateEncodeSwaps } from './utils/validateEncodeSwaps';
+export { NONCE_SKIP_CHECK, generateNonce, EXECUTE_SIGNED_TYPES, getUniversalRouterDomain } from './utils/eip712';

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

@@ -0,0 +1,103 @@
+import { Interface } from '@ethersproject/abi';
+import { BigNumber, BigNumberish } from 'ethers';
+import { MethodParameters, Position as V3Position, RemoveLiquidityOptions as V3RemoveLiquidityOptions } from '@fenine/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 '@fenine/sdk-core';
+import { SwapOptions } from './entities/actions/uniswap';
+import { AcrossV4DepositV3Params } from './entities/actions/across';
+import { SwapSpecification, SwapStep } from './types/encodeSwaps';
+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;
+    /**
+     * Encodes router-provided swap steps inside the SDK safety envelope.
+     *
+     * Routers own `swapSteps` (V2/V3/V4 swaps, plus any `WRAP_ETH` / `UNWRAP_WETH` required by the route).
+     * The SDK owns ingress, fees, final settlement, exact-output refund, and optional `safeMode`.
+     *
+     * Router contract: end with final output in `spec.routing.outputToken`; for `EXACT_OUTPUT`, unused input
+     * must end in `spec.routing.inputToken`. Don't include a top-level `SWEEP` — the SDK appends settlement,
+     * refund, and safeMode sweeps itself.
+     *
+     * Router custody with `payerIsUser = false` is deliberate for safety, even if it costs an extra command
+     * or transfer; the SDK does not infer route topology on behalf of routers.
+     */
+    static encodeSwaps(spec: SwapSpecification, swapSteps: SwapStep[]): 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;
+    /**
+     * Wraps an inner UR plan in calldata targeting the SwapProxy contract.
+     * The proxy pulls ERC20 tokens from the user into the UR, then executes commands.
+     */
+    private static encodeProxyPlan;
+    private static encodeProxyCall;
+}

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

@@ -0,0 +1,149 @@
+import { BigNumberish } from 'ethers';
+import { Currency, CurrencyAmount, Percent, TradeType } from '@fenine/sdk-core';
+import { type PathKey, type PoolKey } from '@uniswap/v4-sdk';
+import { TokenTransferMode } from '../entities/actions/uniswap';
+import { Permit2Permit } from '../utils/inputTokens';
+import { UniversalRouterVersion } from '../utils/constants';
+export type { PathKey, PoolKey };
+export type Fee = {
+    kind: 'portion';
+    recipient: string;
+    fee: Percent;
+} | {
+    kind: 'flat';
+    recipient: string;
+    amount: BigNumberish;
+};
+export type SwapSpecification = {
+    tradeType: TradeType;
+    routing: {
+        inputToken: Currency;
+        outputToken: Currency;
+        amount: CurrencyAmount<Currency>;
+        quote: CurrencyAmount<Currency>;
+    };
+    slippageTolerance: Percent;
+    recipient?: string;
+    fee?: Fee;
+    tokenTransferMode?: TokenTransferMode;
+    permit?: Permit2Permit;
+    chainId?: number;
+    deadline?: BigNumberish;
+    urVersion?: UniversalRouterVersion;
+    safeMode?: boolean;
+};
+export type NormalizedSwapSpecification = Omit<SwapSpecification, 'recipient' | 'tokenTransferMode' | 'urVersion' | 'safeMode'> & {
+    recipient: string;
+    tokenTransferMode: TokenTransferMode;
+    urVersion: UniversalRouterVersion;
+    safeMode: boolean;
+};
+export type V2SwapExactIn = {
+    type: 'V2_SWAP_EXACT_IN';
+    recipient: string;
+    amountIn: BigNumberish;
+    amountOutMin: BigNumberish;
+    path: string[];
+    minHopPriceX36?: BigNumberish[];
+};
+export type V2SwapExactOut = {
+    type: 'V2_SWAP_EXACT_OUT';
+    recipient: string;
+    amountOut: BigNumberish;
+    amountInMax: BigNumberish;
+    path: string[];
+    minHopPriceX36?: BigNumberish[];
+};
+export type V3SwapExactIn = {
+    type: 'V3_SWAP_EXACT_IN';
+    recipient: string;
+    amountIn: BigNumberish;
+    amountOutMin: BigNumberish;
+    path: string;
+    minHopPriceX36?: BigNumberish[];
+};
+export type V3SwapExactOut = {
+    type: 'V3_SWAP_EXACT_OUT';
+    recipient: string;
+    amountOut: BigNumberish;
+    amountInMax: BigNumberish;
+    path: string;
+    minHopPriceX36?: BigNumberish[];
+};
+export type V4Swap = {
+    type: 'V4_SWAP';
+    v4Actions: V4Action[];
+};
+export type WrapEth = {
+    type: 'WRAP_ETH';
+    recipient: string;
+    amount: BigNumberish;
+};
+export type UnwrapWeth = {
+    type: 'UNWRAP_WETH';
+    recipient: string;
+    amountMin: BigNumberish;
+};
+export type SwapStep = V2SwapExactIn | V2SwapExactOut | V3SwapExactIn | V3SwapExactOut | V4Swap | WrapEth | UnwrapWeth;
+export type V4SwapExactIn = {
+    action: 'SWAP_EXACT_IN';
+    currencyIn: string;
+    path: PathKey[];
+    amountIn: BigNumberish;
+    amountOutMinimum: BigNumberish;
+    minHopPriceX36?: BigNumberish[];
+};
+export type V4SwapExactInSingle = {
+    action: 'SWAP_EXACT_IN_SINGLE';
+    poolKey: PoolKey;
+    zeroForOne: boolean;
+    amountIn: BigNumberish;
+    amountOutMinimum: BigNumberish;
+    minHopPriceX36?: BigNumberish;
+    hookData: string;
+};
+export type V4SwapExactOut = {
+    action: 'SWAP_EXACT_OUT';
+    currencyOut: string;
+    path: PathKey[];
+    amountOut: BigNumberish;
+    amountInMaximum: BigNumberish;
+    minHopPriceX36?: BigNumberish[];
+};
+export type V4SwapExactOutSingle = {
+    action: 'SWAP_EXACT_OUT_SINGLE';
+    poolKey: PoolKey;
+    zeroForOne: boolean;
+    amountOut: BigNumberish;
+    amountInMaximum: BigNumberish;
+    minHopPriceX36?: BigNumberish;
+    hookData: string;
+};
+export type V4Settle = {
+    action: 'SETTLE';
+    currency: string;
+    amount: BigNumberish;
+};
+export type V4SettleAll = {
+    action: 'SETTLE_ALL';
+    currency: string;
+    maxAmount: BigNumberish;
+};
+export type V4Take = {
+    action: 'TAKE';
+    currency: string;
+    recipient: string;
+    amount: BigNumberish;
+};
+export type V4TakeAll = {
+    action: 'TAKE_ALL';
+    currency: string;
+    minAmount: BigNumberish;
+};
+export type V4TakePortion = {
+    action: 'TAKE_PORTION';
+    currency: string;
+    recipient: string;
+    bips: BigNumberish;
+};
+export type V4Action = V4SwapExactIn | V4SwapExactInSingle | V4SwapExactOut | V4SwapExactOutSingle | V4Settle | V4SettleAll | V4Take | V4TakeAll | V4TakePortion;

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/computeEncodeSwapsAmounts.d.ts

@@ -0,0 +1,8 @@
+import { BigNumber } from 'ethers';
+import { NormalizedSwapSpecification } from '../types/encodeSwaps';
+export type EncodeSwapsAmounts = {
+    exactOrMaxAmountIn: BigNumber;
+    grossMinOrExactAmountOut: BigNumber;
+    netMinOrExactAmountOut: BigNumber;
+};
+export declare function computeEncodeSwapsAmounts(spec: NormalizedSwapSpecification): EncodeSwapsAmounts;

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

@@ -0,0 +1,39 @@
+import { BigNumber } from 'ethers';
+export declare enum UniversalRouterVersion {
+    V1_2 = "1.2",
+    V2_0 = "2.0",
+    V2_1_1 = "2.1.1"
+}
+/**
+ * Check if a UniversalRouterVersion is at least V2_1_1.
+ * Duplicated from @uniswap/v4-sdk's isAtLeastV2_1_1 (which operates on URVersion)
+ * to avoid coupling universal-router-sdk's version logic to v4-sdk.
+ */
+export declare function isAtLeastV2_1_1(version?: UniversalRouterVersion): boolean;
+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/encodeSwapStep.d.ts

@@ -0,0 +1,4 @@
+import { UniversalRouterVersion } from './constants';
+import { RoutePlanner } from './routerCommands';
+import { SwapStep } from '../types/encodeSwaps';
+export declare function encodeSwapStep(planner: RoutePlanner, step: SwapStep, urVersion?: UniversalRouterVersion): void;

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

@@ -0,0 +1,8 @@
+import { Actions, URVersion } from '@uniswap/v4-sdk';
+import { UniversalRouterVersion } from './constants';
+import { V4Action } from '../types/encodeSwaps';
+export declare function toV4URVersion(version?: UniversalRouterVersion): URVersion;
+export declare function encodeV4Action(v4Action: V4Action, urVersion?: UniversalRouterVersion): {
+    action: Actions;
+    params: any[];
+};

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

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

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

@@ -0,0 +1,23 @@
+import { BigintIsh } from '@fenine/sdk-core';
+import { NFTPermitOptions } from '@fenine/v3-sdk';
+import { PermitSingle } from '@fenine/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/normalizeEncodeSwapsSpec.d.ts

@@ -0,0 +1,2 @@
+import { NormalizedSwapSpecification, SwapSpecification } from '../types/encodeSwaps';
+export declare function normalizeEncodeSwapsSpec(spec: SwapSpecification): NormalizedSwapSpecification;