0xtrails 0.16.2 → 0.17.0

package/dist/actions/actionBuilder.d.ts

@@ -1,424 +0,0 @@
-import { Address } from 'ox';
-import { TokenOrAddress, FeePercent, LendActionItem, SwapActionItem, DepositActionItem, CustomActionItem, AssertActionItem } from './types.js';
-import { SwapProvider } from './resolvers.js';
-export { SwapType } from './resolvers.js';
-export type { SwapProvider } from './resolvers.js';
-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;
-};
-export 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;
-    };
-};
-export 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",
- * })
- * ```
- */
-export 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,
- * })
- * ```
- */
-export 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...",
- * })
- * ```
- */
-export 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" } })
- * ```
- */
-export 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,
- * })
- * ```
- */
-export declare function custom(params: BuildCustomParams): CustomActionItem;
-//# sourceMappingURL=actionBuilder.d.ts.map

package/dist/actions/actionBuilder.d.ts.map

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

package/dist/actions/actionBuilder.js

@@ -1,173 +0,0 @@
-import { isZeroAccount as u } from "../utils/address.js";
-import { TRAILS_HYDRATE_PLACEHOLDER_AMOUNT as E, getAmountOffsets as I } from "../placeholder.js";
-import { HydrateSource as g } from "../hydrate/source.js";
-import { DYNAMIC_AMOUNT_MARKER as T } from "./types.js";
-import { isDynamicAmount as l, isDynamicAmountOrMarker as h } from "./dynamic.js";
-import { SwapType as k } from "./resolvers.js";
-import { isAddress as A } from "viem";
-var O = "0x095ea7b3";
-function r(e) {
-  return l(e) ? T : e;
-}
-function a(e, n) {
-  if (h(e)) throw new Error(`assertCondition: dynamic() is not allowed on ${n} — assertions must use a concrete threshold`);
-}
-function f(e, n) {
-  if (e !== void 0 && h(e))
-    throw new Error(`swap: dynamic() is not allowed on ${n} — only amountIn (EXACT_INPUT) or maxAmountIn (EXACT_OUTPUT) may be dynamic; the SDK hydrates them from the tokenIn balance automatically`);
-}
-function v(e, n) {
-  if (typeof e == "bigint") return e;
-  const t = e.trim();
-  if (!/^\d+$/.test(t)) throw new Error(`${n} must be a non-negative integer string or bigint (e.g. 1000000n or "1000000"). Got: ${JSON.stringify(e)}`);
-  return BigInt(t);
-}
-function i(e, n, t) {
-  if (e !== void 0 && n !== void 0) throw new Error(`${t}: cannot specify both amount and amountRaw. Use amount for human-readable decimals (e.g. "1.5") or amountRaw for raw wei (e.g. 1000000n).`);
-  if (n !== void 0) return v(n, t);
-  if (e === void 0 || e === "") throw new Error(`${t}: amount or amountRaw is required`);
-  return e;
-}
-function y(e, n, t) {
-  if (e !== void 0 && n !== void 0) throw new Error(`${t}: cannot specify both amount and amountRaw. Use amount for human-readable decimals (e.g. "1.5") or amountRaw for raw wei (e.g. 1000000n).`);
-  return n !== void 0 ? v(n, t) : e;
-}
-function x(e) {
-  if (!e.marketId) throw new Error("lend: marketId is required");
-  const n = i(e.amount, e.amountRaw, "lend");
-  if (u(e.receiverAddress)) throw new Error("lend: receiverAddress must not be the zero address (position tokens would be irrecoverably lost)");
-  return {
-    type: "lend",
-    marketId: e.marketId,
-    amount: r(n),
-    direction: "enter",
-    ...e.inputToken !== void 0 && { inputToken: e.inputToken },
-    ...e.inputTokenNetwork !== void 0 && { inputTokenNetwork: e.inputTokenNetwork },
-    ...e.receiverAddress !== void 0 && { receiverAddress: e.receiverAddress }
-  };
-}
-function B(e) {
-  if (!e.marketId) throw new Error("deposit: marketId is required");
-  const n = i(e.amount, e.amountRaw, "deposit");
-  if (u(e.receiverAddress)) throw new Error("deposit: receiverAddress must not be the zero address (vault shares would be irrecoverably lost)");
-  return {
-    type: "deposit",
-    marketId: e.marketId,
-    amount: r(n),
-    direction: "enter",
-    ...e.inputToken !== void 0 && { inputToken: e.inputToken },
-    ...e.inputTokenNetwork !== void 0 && { inputTokenNetwork: e.inputTokenNetwork },
-    ...e.receiverAddress !== void 0 && { receiverAddress: e.receiverAddress },
-    ...e.useMaxAllowance !== void 0 && { useMaxAllowance: e.useMaxAllowance }
-  };
-}
-function P(e) {
-  if (!e.tokenIn) throw new Error("swap: tokenIn is required");
-  if (!e.tokenOut) throw new Error("swap: tokenOut is required");
-  if (typeof e.tokenIn == "string" && typeof e.tokenOut == "string" && e.tokenIn.toLowerCase() === e.tokenOut.toLowerCase()) throw new Error("swap: tokenIn and tokenOut must be different tokens");
-  if (u(e.recipient)) throw new Error("swap: recipient must not be the zero address (swap output would be irrecoverably lost)");
-  const n = e.amountIn !== void 0 || e.amountInRaw !== void 0, t = e.amountOut !== void 0 || e.amountOutRaw !== void 0;
-  if (n && t) throw new Error("swap: pass either amountIn (EXACT_INPUT) or amountOut (EXACT_OUTPUT), not both");
-  if (!n && !t) throw new Error("swap: one of amountIn (EXACT_INPUT) or amountOut (EXACT_OUTPUT) is required");
-  const s = e.fee ?? "0.3", w = e.provider ?? "UNISWAP_V3";
-  if (n) {
-    const m = i(e.amountIn, e.amountInRaw, "swap amountIn"), o = y(e.minAmountOut, e.minAmountOutRaw, "swap minAmountOut");
-    return f(o, "minAmountOut"), {
-      type: "swap",
-      swapType: k.EXACT_INPUT,
-      tokenIn: e.tokenIn,
-      tokenOut: e.tokenOut,
-      fee: s,
-      provider: w,
-      amountIn: r(m),
-      ...o !== void 0 && { minAmountOut: r(o) },
-      ...e.recipient !== void 0 && { recipient: e.recipient }
-    };
-  }
-  const d = i(e.amountOut, e.amountOutRaw, "swap amountOut");
-  f(d, "amountOut");
-  const c = y(e.maxAmountIn, e.maxAmountInRaw, "swap maxAmountIn");
-  return {
-    type: "swap",
-    swapType: k.EXACT_OUTPUT,
-    tokenIn: e.tokenIn,
-    tokenOut: e.tokenOut,
-    fee: s,
-    provider: w,
-    amountOut: r(d),
-    maxAmountIn: c === void 0 ? T : r(c),
-    ...e.recipient !== void 0 && { recipient: e.recipient }
-  };
-}
-function D(e) {
-  if ("erc20Balance" in e) {
-    const n = e.erc20Balance, t = i(n.gte, n.gteRaw, "assertCondition erc20Balance.gte");
-    return a(t, "erc20Balance.gte"), {
-      type: "assert",
-      assertType: "erc20Balance",
-      token: n.token,
-      gte: r(t)
-    };
-  }
-  if ("nativeBalance" in e) {
-    const n = e.nativeBalance, t = i(n.gte, n.gteRaw, "assertCondition nativeBalance.gte");
-    return a(t, "nativeBalance.gte"), {
-      type: "assert",
-      assertType: "nativeBalance",
-      gte: r(t)
-    };
-  }
-  if ("notExpired" in e) return {
-    type: "assert",
-    assertType: "notExpired",
-    deadline: e.notExpired.deadline
-  };
-  if ("erc20Allowance" in e) {
-    const n = e.erc20Allowance, t = i(n.gte, n.gteRaw, "assertCondition erc20Allowance.gte");
-    return a(t, "erc20Allowance.gte"), {
-      type: "assert",
-      assertType: "erc20Allowance",
-      token: n.token,
-      spender: n.spender,
-      gte: r(t)
-    };
-  }
-  throw new Error("assertCondition: unknown assertion type");
-}
-function $(e) {
-  if (!e.to) throw new Error("custom: to address is required");
-  if (u(e.to)) throw new Error("custom: to must not be the zero address");
-  if (u(e.dynamicAmountToken)) throw new Error("custom: dynamicAmountToken must not be the zero address");
-  for (const o of e.dynamicAmountTokens ?? []) {
-    if (!A(o)) throw new Error(`custom: invalid dynamicAmountTokens entry: ${o}`);
-    if (u(o)) throw new Error("custom: dynamicAmountTokens must not contain the zero address");
-  }
-  for (const o of e.sweepTokens ?? []) if (!A(o)) throw new Error(`custom: invalid sweepTokens entry: ${o}`);
-  const n = e.data ?? "0x";
-  if (e.dynamicAmountToken !== void 0 && e.dynamicAmountTokens !== void 0) throw new Error("custom: use either dynamicAmountToken or dynamicAmountTokens, not both.");
-  if (e.dynamicAmountTokens?.length === 0) throw new Error("custom: dynamicAmountTokens cannot be empty.");
-  const t = I(n, E).length, s = t > 0, w = n.slice(0, 10).toLowerCase() === O;
-  if (e.dynamicAmountTokens !== void 0 && e.dynamicAmountTokens.length !== t) throw new Error("custom: dynamicAmountTokens length must match the number of dynamic() amount slots.");
-  if (s && !e.dynamicAmountToken && !e.dynamicAmountTokens && !w) throw new Error("custom: calldata contains a dynamic() amount sentinel, but no `dynamicAmountToken` was provided. Set `dynamicAmountToken` or `dynamicAmountTokens` to the ERC-20 address whose runtime balance should replace the sentinel. (Inference from `to` is only available for bare `approve(spender, dynamic())` calls.)");
-  const d = l(e.value), c = d ? 0n : e.value, m = d ? [{
-    type: "value",
-    address: g.self()
-  }] : [];
-  return {
-    type: "custom",
-    to: e.to,
-    data: n,
-    ...c !== void 0 && { value: c },
-    ...e.dynamicAmountToken !== void 0 && { dynamicAmountToken: e.dynamicAmountToken },
-    ...e.dynamicAmountTokens !== void 0 && { dynamicAmountTokens: e.dynamicAmountTokens },
-    ...e.sweepTokens !== void 0 && { sweepTokens: e.sweepTokens },
-    ...m.length > 0 && { hydrateEntries: m }
-  };
-}
-export {
-  D as assertCondition,
-  $ as custom,
-  B as deposit,
-  x as lend,
-  P as swap
-};