0xtrails 0.16.2 → 0.17.0

package/dist/sushiswapV3-D3h41LNZ.d.ts

@@ -0,0 +1,723 @@
+import { D as TokenOrAddress, O as SwapProvider, S as LendActionItem, _ as CustomActionItem, a as AssertActionItem, b as FeePercent, f as Call$1, h as ChainIdentifier, r as ActionItem, v as DepositActionItem, w as SwapActionItem } from "./types-BK0WkVnx.js";
+import { IntentProtocolVersion, TrailsApi } from "@0xtrails/api";
+import { PublicClient } from "viem";
+import { Address } from "ox";
+
+//#region src/actions/actionBuilder.d.ts
+type LendBuilderParams = {
+  marketId: string;
+  amount?: string;
+  amountRaw?: bigint | string;
+  inputToken?: string;
+  inputTokenNetwork?: string;
+  receiverAddress?: `0x${string}`;
+};
+type DepositBuilderParams = {
+  marketId: string;
+  amount?: string;
+  amountRaw?: bigint | string;
+  inputToken?: string;
+  inputTokenNetwork?: string;
+  receiverAddress?: `0x${string}`;
+  useMaxAllowance?: boolean;
+};
+type SwapCommonBuilderParams = {
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee?: FeePercent;
+  provider?: SwapProvider;
+  /**
+   * Where the swap output is sent. Defaults to the user's wallet for the
+   * last action in a batch, and to `self()` (the intent wallet, via the
+   * hydration encoder) for intermediate actions so downstream steps can
+   * consume the output.
+   *
+   * Pass `self()` to explicitly route output back to the intent wallet,
+   * or a concrete `0x…` address to forward to a third party.
+   */
+  recipient?: Address.Address;
+};
+type SwapExactInputBuilderParams = SwapCommonBuilderParams & {
+  amountIn?: string;
+  amountInRaw?: bigint | string;
+  minAmountOut?: string;
+  minAmountOutRaw?: bigint | string;
+  amountOut?: never;
+  amountOutRaw?: never;
+  maxAmountIn?: never;
+  maxAmountInRaw?: never;
+};
+type SwapExactOutputBuilderParams = SwapCommonBuilderParams & {
+  amountOut?: string;
+  amountOutRaw?: bigint | string;
+  maxAmountIn?: string;
+  maxAmountInRaw?: bigint | string;
+  amountIn?: never;
+  amountInRaw?: never;
+  minAmountOut?: never;
+  minAmountOutRaw?: never;
+};
+type SwapBuilderParams = SwapExactInputBuilderParams | SwapExactOutputBuilderParams;
+type BuildCustomParams = {
+  to: Address.Address;
+  /**
+   * Raw calldata for the target contract. Omit for native ETH transfers.
+   */
+  data?: `0x${string}`;
+  /**
+   * Native value (`msg.value`) to send with this call.
+   *
+   * - `bigint` — static amount in wei.
+   * - `dynamic()` — use the intent wallet's native balance at execution time.
+   *   The SDK strips the sentinel to `0n` in the encoded payload and attaches
+   *   a `{ type: "value", address: "self" }` hydration entry so HydrateProxy
+   *   overwrites `msg.value` just before the call runs. Use this for payable
+   *   deposits (WETH.deposit(), native-ETH vaults, etc.) where the arriving
+   *   ETH amount isn't known at build time.
+   */
+  value?: bigint;
+  /**
+   * The ERC-20 token the `dynamic()` amount in `data` refers to.
+   *
+   * At execution time the SDK reads the intent wallet's balance of this token
+   * and writes it into the `dynamic()` slot in `data`.
+   *
+   * Required whenever `data` contains a `dynamic()` amount. The one exception
+   * is a bare `approve(spender, dynamic())` call, where `to` is already the
+   * token contract and the SDK infers it automatically.
+   */
+  dynamicAmountToken?: Address.Address;
+  /**
+   * ERC-20 tokens for calls with multiple `dynamic()` amount slots that spend
+   * different runtime balances. Tokens are matched in encoded calldata order.
+   */
+  dynamicAmountTokens?: Address.Address[];
+  /**
+   * Additional ERC-20 or native assets to sweep back to the user after this
+   * opaque call runs.
+   */
+  sweepTokens?: Address.Address[];
+};
+type AssertERC20BalanceParams = {
+  erc20Balance: {
+    token: TokenOrAddress;
+    gte?: string;
+    gteRaw?: bigint | string;
+  };
+};
+type AssertNativeBalanceParams = {
+  nativeBalance: {
+    gte?: string;
+    gteRaw?: bigint | string;
+  };
+};
+type AssertNotExpiredParams = {
+  notExpired: {
+    deadline: number;
+  };
+};
+type AssertERC20AllowanceParams = {
+  erc20Allowance: {
+    token: TokenOrAddress;
+    spender: `0x${string}`;
+    gte?: string;
+    gteRaw?: bigint | string;
+  };
+};
+type AssertBuilderParams = AssertERC20BalanceParams | AssertNativeBalanceParams | AssertNotExpiredParams | AssertERC20AllowanceParams;
+/**
+ * Supply liquidity to a supported lending market such as Aave on the
+ * destination chain.
+ *
+ * ### Discovering market IDs
+ *
+ * Don't hardcode IDs — the Trails API catalogue evolves and the ID shape
+ * varies across providers. Fetch the live list:
+ * - `getEarnMarkets({ type: "lending", chain, ... })` — programmatic,
+ *   returns a promise.
+ * - `useEarnMarkets({ type: "lending", chain, ... })` — React hook,
+ *   React Query–backed.
+ *
+ * Both accept filters by `chain`, `type`, `provider`, free-text `search`,
+ * and pagination. Each returned market exposes `.id` (pass to `marketId`),
+ * `.token`, `.rewardRate`, `.statistics.tvlUsd`, and provider metadata.
+ *
+ * ```ts
+ * import { useEarnMarkets, lend } from "0xtrails"
+ *
+ * const { data: markets } = useEarnMarkets({
+ *   chain: "base",
+ *   type: "lending",
+ *   sortBy: "rewardRateDesc",
+ * })
+ *
+ * const action = markets?.[0] &&
+ *   lend({ marketId: markets[0].id, amount: "50" })
+ * ```
+ *
+ * ### Amounts
+ *
+ * - `string` — human-readable (e.g. `"50"`), scaled by the underlying
+ *   token's decimals.
+ * - `bigint` — raw wei.
+ * - `dynamic()` — supply the intent wallet's full runtime balance of the
+ *   market's input token. The resolver returns calldata with a placeholder
+ *   that HydrateProxy replaces at execution time, and emits a fresh
+ *   `approve(spender, dynamic())` for the same balance.
+ *
+ * ### Position ownership
+ *
+ * `receiverAddress` defaults to the connected user wallet, so aTokens /
+ * fTokens / cTokens land on the user's EOA by default. Override only
+ * when you want the position to belong to a different owner (smart
+ * account, treasury, …).
+ *
+ * @remarks
+ * Only supply (enter) is supported. Withdrawals are not part of the
+ * Trails intent pipeline — use the protocol's own withdrawal flow
+ * directly.
+ *
+ * @example
+ * Supply 50 USDC to a lending market on Base:
+ * ```ts
+ * lend({
+ *   marketId: "base-usdc-aave-v3-lending",
+ *   amount: "50",
+ * })
+ * ```
+ */
+declare function lend(params: LendBuilderParams): LendActionItem;
+/**
+ * Deposit into a vault-style market — ERC-4626 vaults, Morpho, Yearn,
+ * SummerFi, Sky, etc. — on the destination chain.
+ *
+ * Use `deposit` for anything that isn't covered by `lend` (money-market
+ * supply): curated vaults, structured products, LP-style deposits that
+ * return a share token.
+ *
+ * ### Discovering market IDs
+ *
+ * Don't hardcode IDs — fetch the live catalogue via
+ * `getEarnMarkets({ type: "vault", chain, ... })` (promise) or
+ * `useEarnMarkets({ type: "vault", chain, ... })` (React hook). Each
+ * returned market exposes `.id` — pass it straight into `marketId`.
+ *
+ * ### Amounts
+ *
+ * - `string` — human-readable (e.g. `"100"`), scaled by the vault's input
+ *   token decimals.
+ * - `bigint` — raw wei.
+ * - `dynamic()` — deposit the intent wallet's full runtime balance of the
+ *   vault's input token.
+ *
+ * ### Custody and allowance
+ *
+ * - `receiverAddress` — defaults to the connected user wallet, so shares
+ *   mint to the user by default. Override only to send shares to a
+ *   different owner (smart account, treasury, …).
+ * - `useMaxAllowance` — when `true` the resolver emits a `uint256.max`
+ *   approve instead of an exact-amount approve. Reduces gas on subsequent
+ *   deposits at the cost of a broader allowance.
+ *
+ * @remarks
+ * Only deposit (enter) is supported. Redemptions are not part of the
+ * Trails intent pipeline — use the protocol's own withdrawal flow
+ * directly.
+ *
+ * @example
+ * Deposit 50 USDC into a vault:
+ * ```ts
+ * deposit({
+ *   marketId: "base-usdc-pusdc-0x1401d1271c47648ac70cbcdfa3776d4a87ce006b-4626-vault",
+ *   amount: "50",
+ * })
+ * ```
+ *
+ * @example
+ * Deposit 100 USDC, mint shares to a different owner (overriding the
+ * default EOA receiver), with unlimited allowance:
+ * ```ts
+ * deposit({
+ *   marketId: "base-usdc-pusdc-0x1401d1271c47648ac70cbcdfa3776d4a87ce006b-4626-vault",
+ *   amount: "100",
+ *   receiverAddress: "0xabc...", // only needed when you don't want the user's EOA
+ *   useMaxAllowance: true,
+ * })
+ * ```
+ */
+declare function deposit(params: DepositBuilderParams): DepositActionItem;
+/**
+ * Swap one token for another on the destination chain, executed through a
+ * supported on-chain router (Uniswap V3 or SushiSwap V3). Use this for
+ * intra-batch token conversions — e.g. bridge USDC, swap to WETH, then
+ * lend the WETH.
+ *
+ * ### Trade type (inferred)
+ *
+ * Exactly one of `amountIn` / `amountOut` must be provided:
+ * - `amountIn`  → EXACT_INPUT  (spend an exact amount, receive at least `minAmountOut`).
+ * - `amountOut` → EXACT_OUTPUT (receive an exact amount, spend up to `maxAmountIn`).
+ *
+ * Setting both, or neither, throws at build time.
+ *
+ * ### Amounts
+ *
+ * - `string` — human-readable (e.g. `"1.25"`), scaled by the relevant
+ *   token's decimals.
+ * - `bigint` — raw wei.
+ * - `dynamic()` — permitted on `amountIn` (EXACT_INPUT) and `maxAmountIn`
+ *   (EXACT_OUTPUT) only. Forbidden on `amountOut` / `minAmountOut`, which
+ *   must be concrete thresholds. When `maxAmountIn` is omitted for
+ *   EXACT_OUTPUT it defaults to `dynamic()`, letting Trails spend whatever
+ *   `tokenIn` balance lands at runtime.
+ *
+ * ### Pool fee tier (`fee`)
+ *
+ * Selects the V3 pool tier:
+ * - `"0.01"` — 0.01% (stablecoin ↔ stablecoin).
+ * - `"0.05"` — 0.05% (correlated pairs, e.g. stETH/ETH).
+ * - `"0.3"`  — 0.3%, default (most volatile pairs).
+ * - `"1"`    — 1% (exotic pairs).
+ *
+ * ### Provider
+ *
+ * Defaults to `"UNISWAP_V3"`. Pass `"SUSHISWAP_V3"` to route through
+ * SushiSwap. If the chosen provider isn't deployed on the destination
+ * chain the resolver throws with a suggested alternative.
+ *
+ * ### Recipient
+ *
+ * Controls where the swap output is delivered:
+ * - Omitted — the resolver routes to the user's wallet for the final
+ *   action, and to `self()` for intermediate actions so the next step can
+ *   consume the output from the intent wallet's balance.
+ * - `self()` — force delivery back to the intent wallet (via the
+ *   hydration encoder at execution time).
+ * - `0x...` — forward to a third-party address.
+ *
+ * @example
+ * Swap an exact amount (EXACT_INPUT) of WETH to USDC:
+ * ```ts
+ * swap({
+ *   tokenIn: "WETH",
+ *   tokenOut: "USDC",
+ *   amountIn: "1",            // spend 1 WETH
+ *   minAmountOut: "3000",     // revert if output < 3000 USDC
+ *   fee: "0.05",
+ * })
+ * ```
+ *
+ * @example
+ * Swap for an exact amount of USDC (EXACT_OUTPUT), capped by a maximum
+ * spend:
+ * ```ts
+ * swap({
+ *   tokenIn: "WETH",
+ *   tokenOut: "USDC",
+ *   amountOut: "3000",        // must receive 3000 USDC
+ *   maxAmountIn: "2",         // spend at most 2 WETH
+ * })
+ * ```
+ *
+ * @example
+ * Chain a swap into a lending supply:
+ * ```ts
+ * const actions = [
+ *   swap({
+ *     tokenIn: "USDC",
+ *     tokenOut: "WETH",
+ *     amountIn: "100",
+ *     minAmountOut: "0.03",
+ *   }),
+ *   lend({
+ *     marketId: "base-weth-aave-v3-lending",
+ *     amount: "0.03",
+ *   }),
+ * ]
+ * ```
+ *
+ * @example
+ * Route the swap output to a third party via SushiSwap:
+ * ```ts
+ * swap({
+ *   provider: "SUSHISWAP_V3",
+ *   tokenIn: "USDC",
+ *   tokenOut: "WETH",
+ *   amountIn: "100",
+ *   recipient: "0xabc...",
+ * })
+ * ```
+ */
+declare function swap(params: SwapBuilderParams): SwapActionItem;
+/**
+ * Insert an on-chain condition check into the batch. If the condition fails
+ * at execution time the entire batch reverts.
+ *
+ * Conditions compile to calls against the deployed `RequireUtils` contract
+ * (part of `TrailsUtils`).
+ *
+ * Named `assertCondition` (not `assert`) to avoid shadowing `node:assert`
+ * and test-framework `assert` helpers at import sites.
+ *
+ * @example
+ * ```ts
+ * // Revert if the wallet holds less than 2,400 USDC after the swap
+ * assertCondition({ erc20Balance: { token: "USDC", gte: "2400" } })
+ *
+ * // Revert if native balance is below 0.5 ETH
+ * assertCondition({ nativeBalance: { gte: "0.5" } })
+ *
+ * // Revert if the batch is executed after the deadline
+ * assertCondition({ notExpired: { deadline: 1712600000 } })
+ *
+ * // Revert if allowance is insufficient
+ * assertCondition({ erc20Allowance: { token: "USDC", spender: "0x...", gte: "1000" } })
+ * ```
+ */
+declare function assertCondition(params: AssertBuilderParams): AssertActionItem;
+/**
+ * Wrap a raw contract call as an action item. Use this for custom protocol
+ * interactions not covered by the typed builders. Omit `data` for native ETH
+ * transfers; the builder normalizes empty calldata to `"0x"` for execution.
+ *
+ * ### `dynamic()` amounts in custom calldata
+ *
+ * If `data` contains a `dynamic()` sentinel, you must set
+ * `dynamicAmountToken` to the ERC-20 whose runtime balance should replace
+ * the sentinel — **unless** the call itself is an `approve(spender,
+ * dynamic())`, in which case `to` IS the token contract and the encoder
+ * infers it. There is no implicit fallback to the batch destination token;
+ * forgetting `dynamicAmountToken` throws at build time.
+ *
+ * ### `dynamic()` for native `msg.value`
+ *
+ * Pass `value: dynamic()` for payable calls whose `msg.value` must equal the
+ * intent wallet's runtime native balance (e.g. `WETH.deposit()`, native-ETH
+ * vault deposits). The SDK strips the sentinel to `0n` in the encoded
+ * payload and attaches a `{ type: "value", address: "self" }` hydration
+ * entry so HydrateProxy overwrites `msg.value` just before the call runs —
+ * callers don't author hydration entries directly.
+ *
+ * @example
+ * ```ts
+ * // Raw Uniswap swap with dynamic amountIn — dynamicAmountToken REQUIRED
+ * custom({
+ *   to: UNISWAP_ROUTER,
+ *   data: encodeExactInputSingle({ tokenIn: USDC, amountIn: dynamic(), ... }),
+ *   dynamicAmountToken: USDC, // ← tells the encoder to hydrate from balanceOf(USDC)
+ * })
+ *
+ * // Payable WETH.deposit() with runtime-resolved msg.value
+ * custom({
+ *   to: WETH,
+ *   data: encodeFunctionData({ abi: wethAbi, functionName: "deposit", args: [] }),
+ *   value: dynamic(), // ← SDK auto-hydrates msg.value from the wallet's ETH balance
+ * })
+ *
+ * // Plain ETH transfer
+ * custom({
+ *   to: "0xabc...",
+ *   value: 1_000_000_000_000_000n,
+ * })
+ * ```
+ */
+declare function custom(params: BuildCustomParams): CustomActionItem;
+//#endregion
+//#region src/actions/dynamic.d.ts
+/**
+ * Returns a sentinel `bigint` that tells the SDK to resolve this amount at
+ * runtime (full ERC-20 balance of the intent wallet when the batch executes).
+ *
+ * Accepted by amount fields that spend a runtime balance: `lend.amount`,
+ * `deposit.amount`, `swap.amountIn`, `swap.maxAmountIn`, and custom calldata
+ * / native `value` fields that explicitly support hydration. Not accepted by
+ * output thresholds (`swap.amountOut`, `swap.minAmountOut`) or
+ * `assertCondition`: those must use concrete values.
+ *
+ * For chained actions — where the output of one step feeds the input of the
+ * next — mark the consuming step with `dynamic()` so the hydration encoder
+ * injects the real balance at execution time.
+ *
+ * @example
+ * ```ts
+ * import { dynamic, swap } from "0xtrails"
+ *
+ * swap({
+ *   tokenIn: "WETH",
+ *   tokenOut: "USDC",
+ *   amountIn: dynamic(), // EXACT_INPUT (inferred from amountIn)
+ *   fee: "0.3",
+ * })
+ * ```
+ */
+type DynamicAmount = string & bigint & {
+  readonly __brand: "dynamic";
+};
+declare function dynamic(): DynamicAmount;
+/**
+ * Returns the sentinel address that tells the hydration encoder to inject
+ * `address(this)` (the intent wallet address) at execution time.
+ *
+ * Use this anywhere an address is expected to mean "the smart wallet
+ * executing this batch." `swap` sets a sensible default recipient for you,
+ * but you can pass `self()` explicitly when composing actions (for example
+ * to make an intermediate swap's output available to the next step).
+ *
+ * @example
+ * ```ts
+ * import { self, dynamic, swap } from "0xtrails"
+ *
+ * swap({
+ *   tokenIn: "WETH",
+ *   tokenOut: "USDC",
+ *   amountIn: dynamic(),
+ *   fee: "0.3",
+ *   // output goes back to the intent wallet for the next step
+ *   recipient: self(),
+ * })
+ * ```
+ */
+declare function self(): Address.Address;
+/**
+ * Prefer this helper over raw `=== TRAILS_HYDRATE_PLACEHOLDER_AMOUNT` checks
+ * — it does a safe type-narrowed comparison so adding new amount shapes
+ * later only requires updating one call site.
+ */
+declare function isDynamicAmount(value: unknown): boolean;
+/**
+ * Single source of truth for "is this address the `self()` sentinel?".
+ *
+ * Case-insensitive; accepts any `0x`-prefixed string (or `undefined`, in
+ * which case this returns `false`).
+ */
+declare function isSelfAddress(value: unknown): boolean;
+//#endregion
+//#region src/actions/resolveActions.d.ts
+type ResolveActionsToCallsParams = {
+  actions: ActionItem[];
+  destinationChain: ChainIdentifier;
+  userWalletAddress: `0x${string}`;
+  trailsClient: TrailsApi;
+  publicClient: PublicClient | null;
+  abortSignal?: AbortSignal;
+};
+declare function resolveActionsToCalls(params: ResolveActionsToCallsParams): Promise<Call$1[]>;
+//#endregion
+//#region src/actions/destinationCalls.d.ts
+type DestinationCallsInput = (Call$1 | Call$1[])[] | Call$1[] | null | undefined;
+type EncodedDestinationCalls = {
+  recipient: `0x${string}`;
+  destinationCalldata: `0x${string}`;
+  isMultiCallEncoding: true;
+  intentProtocolVersion: IntentProtocolVersion;
+};
+declare function flattenDestinationCalls(calls: DestinationCallsInput): Call$1[];
+declare function encodeDestinationCalls({
+  calls,
+  tokenAddress,
+  sweepTarget,
+  intentProtocolVersion
+}: {
+  calls: Call$1[];
+  tokenAddress: `0x${string}`;
+  sweepTarget: `0x${string}`;
+  intentProtocolVersion?: IntentProtocolVersion | null;
+}): EncodedDestinationCalls;
+//#endregion
+//#region src/actions/custom-integrations/uniswapV3/types.d.ts
+type UniswapV3SwapExactInputSingleParams = {
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  recipient: Address.Address;
+  amountIn: bigint;
+  amountOutMinimum: bigint;
+  sqrtPriceLimitX96?: bigint;
+};
+type UniswapV3SwapExactOutputSingleParams = {
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  recipient: Address.Address;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  sqrtPriceLimitX96?: bigint;
+};
+type UniswapV3GetPoolParams = {
+  token0: TokenOrAddress;
+  token1: TokenOrAddress;
+  fee: FeePercent;
+};
+type UniswapV3QuoteSwapType = "exactInputSingle" | "exactOutputSingle";
+type UniswapV3QuoteSwapParams = {
+  type: UniswapV3QuoteSwapType;
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  /**
+   * Input amount for `exactInputSingle`. Ignored by `exactOutputSingle`;
+   * pass `0n` there and set `amountOutMinimum` to the desired output.
+   */
+  amountIn: bigint;
+  /**
+   * Used as desired output amount for exactOutputSingle quote type.
+   */
+  amountOutMinimum?: bigint;
+};
+type UniswapV3QuoteSwapResponse = {
+  type: UniswapV3QuoteSwapType;
+  tokenIn: Address.Address;
+  tokenOut: Address.Address;
+  /**
+   * Uniswap V3 fee-tier integer (e.g. `3000` for the 0.3% tier) — the value
+   * passed to `IUniswapV3Pool.fee()`. NOT basis points; tiers are in
+   * hundredths of a basis point.
+   */
+  feeTier: number;
+  amountIn?: bigint;
+  amountOut?: bigint;
+  sqrtPriceX96After?: bigint;
+  initializedTicksCrossed?: number;
+  gasEstimate?: bigint;
+};
+type UniswapV3ChainScoped = {
+  /**
+   * Build approval + Uniswap V3 exact-input swap calls.
+   *
+   * Amounts are raw `bigint` smallest units. Use `parseUnits` before calling
+   * this low-level helper.
+   *
+   * @returns `[approve, swap]` — a {@link Call} array ready for `to.calls`.
+   */
+  swapExactInputSingle: (params: UniswapV3SwapExactInputSingleParams) => Call$1[];
+  /**
+   * Build approval + Uniswap V3 exact-output swap calls.
+   *
+   * Amounts are raw `bigint` smallest units. Use `parseUnits` before calling
+   * this low-level helper.
+   *
+   * @returns `[approve, swap]` — a {@link Call} array ready for `to.calls`.
+   */
+  swapExactOutputSingle: (params: UniswapV3SwapExactOutputSingleParams) => Call$1[];
+  /**
+   * Queries the Uniswap V3 Factory on-chain to get the pool address for a token pair and fee tier.
+   * Tokens are auto-sorted; order does not matter.
+   * @returns The pool address, or `null` if no pool exists.
+   */
+  getPool: (params: UniswapV3GetPoolParams) => Promise<Address.Address | null>;
+  /**
+   * Fetches a Uniswap V3 single-hop quote via QuoterV2.
+   * - exactInputSingle uses `amountIn`.
+   * - exactOutputSingle uses `amountOutMinimum` as the desired output amount.
+   */
+  quoteSwap: (params: UniswapV3QuoteSwapParams) => Promise<UniswapV3QuoteSwapResponse>;
+};
+//#endregion
+//#region src/actions/custom-integrations/uniswapV3/uniswapV3.d.ts
+declare const uniswapV3: {
+  onChain: (chain: ChainIdentifier) => UniswapV3ChainScoped;
+  factoryAddressOn: (chain: ChainIdentifier) => import("ox/Address").Address;
+  isSupportedOn: (chain: ChainIdentifier) => boolean;
+  swapRouterAddressOn: (chain: ChainIdentifier) => import("ox/Address").Address;
+};
+//#endregion
+//#region src/actions/custom-integrations/sushiswapV3/types.d.ts
+type SushiSwapV3SwapExactInputSingleParams = {
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  recipient: Address.Address;
+  deadline: bigint;
+  amountIn: bigint;
+  amountOutMinimum: bigint;
+  sqrtPriceLimitX96?: bigint;
+};
+type SushiSwapV3SwapExactOutputSingleParams = {
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  recipient: Address.Address;
+  deadline: bigint;
+  amountOut: bigint;
+  amountInMaximum: bigint;
+  sqrtPriceLimitX96?: bigint;
+};
+type SushiSwapV3GetPoolParams = {
+  token0: TokenOrAddress;
+  token1: TokenOrAddress;
+  fee: FeePercent;
+};
+type SushiSwapV3QuoteSwapType = "exactInputSingle" | "exactOutputSingle";
+type SushiSwapV3QuoteSwapParams = {
+  type: SushiSwapV3QuoteSwapType;
+  tokenIn: TokenOrAddress;
+  tokenOut: TokenOrAddress;
+  fee: FeePercent;
+  /**
+   * Input amount for `exactInputSingle`. Ignored by `exactOutputSingle`;
+   * pass `0n` there and set `amountOutMinimum` to the desired output.
+   */
+  amountIn: bigint;
+  /**
+   * Used as desired output amount for exactOutputSingle quote type.
+   */
+  amountOutMinimum?: bigint;
+  sqrtPriceLimitX96?: bigint;
+};
+type SushiSwapV3QuoteSwapResponse = {
+  type: SushiSwapV3QuoteSwapType;
+  tokenIn: Address.Address;
+  tokenOut: Address.Address;
+  /**
+   * SushiSwap V3 fee-tier integer (e.g. `3000` for the 0.3% tier), matching
+   * Uniswap V3's encoding. NOT basis points.
+   */
+  feeTier: number;
+  amountIn?: bigint;
+  amountOut?: bigint;
+  sqrtPriceX96After?: bigint;
+  initializedTicksCrossed?: number;
+  gasEstimate?: bigint;
+};
+type SushiSwapV3ChainScoped = {
+  /**
+   * Build approval + SushiSwap V3 exact-input swap calls.
+   *
+   * Amounts are raw `bigint` smallest units. Use `parseUnits` before calling
+   * this low-level helper. SushiSwap V3 also requires a unix `deadline`.
+   *
+   * @returns `[approve, swap]` — a {@link Call} array ready for `to.calls`.
+   */
+  swapExactInputSingle: (params: SushiSwapV3SwapExactInputSingleParams) => Call$1[];
+  /**
+   * Build approval + SushiSwap V3 exact-output swap calls.
+   *
+   * Amounts are raw `bigint` smallest units. Use `parseUnits` before calling
+   * this low-level helper. SushiSwap V3 also requires a unix `deadline`.
+   *
+   * @returns `[approve, swap]` — a {@link Call} array ready for `to.calls`.
+   */
+  swapExactOutputSingle: (params: SushiSwapV3SwapExactOutputSingleParams) => Call$1[];
+  /**
+   * Queries the SushiSwap V3 Factory on-chain to get the pool address for a token pair and fee tier.
+   * Tokens are auto-sorted; order does not matter.
+   * @returns The pool address, or `null` if no pool exists.
+   */
+  getPool: (params: SushiSwapV3GetPoolParams) => Promise<Address.Address | null>;
+  /**
+   * Fetches a SushiSwap V3 single-hop quote via the V3 Quoter.
+   * - exactInputSingle uses `amountIn`.
+   * - exactOutputSingle uses `amountOutMinimum` as the desired output amount.
+   */
+  quoteSwap: (params: SushiSwapV3QuoteSwapParams) => Promise<SushiSwapV3QuoteSwapResponse>;
+};
+//#endregion
+//#region src/actions/custom-integrations/sushiswapV3/sushiswapV3.d.ts
+declare const sushiswapV3: {
+  onChain: (chain: ChainIdentifier) => SushiSwapV3ChainScoped;
+  factoryAddressOn: (chain: ChainIdentifier) => import("ox/Address").Address;
+  isSupportedOn: (chain: ChainIdentifier) => boolean;
+  swapRouterAddressOn: (chain: ChainIdentifier) => import("ox/Address").Address;
+};
+//#endregion
+export { deposit as A, DynamicAmount as C, self as D, isSelfAddress as E, swap as M, assertCondition as O, resolveActionsToCalls as S, isDynamicAmount as T, DestinationCallsInput as _, SushiSwapV3QuoteSwapResponse as a, flattenDestinationCalls as b, SushiSwapV3SwapExactOutputSingleParams as c, UniswapV3GetPoolParams as d, UniswapV3QuoteSwapParams as f, UniswapV3SwapExactOutputSingleParams as g, UniswapV3SwapExactInputSingleParams as h, SushiSwapV3QuoteSwapParams as i, lend as j, custom as k, uniswapV3 as l, UniswapV3QuoteSwapType as m, SushiSwapV3ChainScoped as n, SushiSwapV3QuoteSwapType as o, UniswapV3QuoteSwapResponse as p, SushiSwapV3GetPoolParams as r, SushiSwapV3SwapExactInputSingleParams as s, sushiswapV3 as t, UniswapV3ChainScoped as u, EncodedDestinationCalls as v, dynamic as w, ResolveActionsToCallsParams as x, encodeDestinationCalls as y };