@lifi/composer-sdk 0.7.0 → 0.8.1

package/src/examples/aaveBorrow.ts

@@ -0,0 +1,129 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  createComposeSdk,
+  guards,
+  materialisers,
+  resources,
+} from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Aave v3 contracts on Ethereum mainnet.
+const AAVE_V3_POOL = '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2';
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+// Aave v3 aEthUSDC receipt token and variable-debt USDC token.
+const A_ETH_USDC = '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c';
+const VDEBT_USDC = '0x72E95b8931767C79bA4EeE721354d6E99a61D004';
+
+// 1.05 WAD (1e18) — minimum acceptable Aave health factor after the borrow.
+// The on-chain VM reverts the run if the post-borrow HF drops below this.
+const MIN_HEALTH_FACTOR_WAD = '1050000000000000000';
+
+export interface AaveBorrowInput {
+  readonly owner: Address;
+  readonly recipient: Address;
+  /** USDC supplied as collateral so the proxy can borrow (6 dp). */
+  readonly collateralAmount: `${bigint}`;
+  /** USDC borrowed against the collateral and sent to the recipient (6 dp). */
+  readonly borrowAmount: `${bigint}`;
+}
+
+/**
+ * Supply USDC to Aave v3, borrow USDC against it, and transfer the borrowed
+ * funds to a recipient — with an on-chain health-factor guard that reverts
+ * if the post-borrow position is too thin.
+ *
+ * The in-flow supply makes the example self-contained: the borrow is backed
+ * by collateral created in the same transaction, so it simulates cleanly
+ * for a fresh proxy. Keep `borrowAmount` comfortably below the collateral's
+ * borrowing power or the health-factor guard reverts the run.
+ *
+ * Demonstrates:
+ * - `lifi.zap` to supply USDC into Aave (USDC → aEthUSDC routing edge)
+ * - `aave.borrow` with no resource input — the borrowed asset materialises
+ *   as the `borrowed` resource output.
+ * - Chaining the borrow output into a `core.transfer` to forward funds.
+ * - `aave.getHealthFactor` + `core.numericInvariant` guard asserts that
+ *   `healthFactor >= MIN_HEALTH_FACTOR_WAD` after the borrow; the run reverts
+ *   on-chain if the threshold is violated.
+ *
+ * The supplied aEthUSDC stays on the proxy: it backs the open debt, and
+ * Aave rejects aToken transfers that would break the position's health
+ * factor, so it cannot be swept while the borrow is outstanding.
+ */
+export const buildAaveBorrow = ({
+  owner,
+  recipient,
+  collateralAmount,
+  borrowAmount,
+}: AaveBorrowInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(1, {
+    name: 'aave-borrow-usdc',
+    inputs: {
+      collateralIn: resources.erc20(USDC, 1),
+      recipient: 'address',
+    },
+  });
+
+  // Supply USDC as collateral (USDC → aEthUSDC) so the proxy can borrow.
+  builder.lifi.zap('supply', {
+    bind: { amountIn: builder.inputs.collateralIn },
+    config: { resourceOut: resources.erc20(A_ETH_USDC, 1) },
+  });
+
+  const borrowOut = builder.aave.borrow('borrow', {
+    bind: {},
+    config: {
+      pool: AAVE_V3_POOL,
+      asset: USDC,
+      variableDebtToken: VDEBT_USDC,
+      amount: borrowAmount,
+    },
+  });
+
+  // Read the post-borrow Aave health factor and assert it stays above the
+  // minimum threshold. The numericInvariant guard lowers to an on-chain
+  // `AssertRawInvariant` IR1 instruction; the run reverts if HF < threshold.
+  builder.aave.getHealthFactor('hf', {
+    bind: {},
+    config: { pool: AAVE_V3_POOL },
+    guards: [
+      guards.coreNumericInvariant({
+        port: 'healthFactor',
+        op: 'gte',
+        threshold: MIN_HEALTH_FACTOR_WAD,
+      }),
+    ],
+  });
+
+  // Forward the freshly borrowed USDC to the recipient.
+  builder.core.transfer('send-borrowed', {
+    bind: {
+      amount: borrowOut.borrowed,
+      recipient: builder.inputs.recipient,
+    },
+    config: {},
+  });
+
+  const flow = builder.build();
+
+  // No sweepTo: the aEthUSDC collateral must stay on the proxy while the
+  // debt is open — Aave blocks aToken transfers that would leave the
+  // position undercollateralized.
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      collateralIn: materialisers.directDeposit({ amount: collateralAmount }),
+      recipient,
+    },
+  });
+
+  return { flow, request };
+};

package/src/examples/aaveHealthFactorExplode.ts

@@ -0,0 +1,63 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, guards } from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Base mainnet Aave v3 Pool.
+const AAVE_V3_POOL = '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5';
+
+// 1.0 WAD (1e18) — minimum acceptable health factor.
+const MIN_HEALTH_FACTOR_WAD = '1000000000000000000';
+
+export interface AaveHealthFactorExplodeInput {
+  readonly signer: Address;
+}
+
+/**
+ * EXPLODE / DecomposeValue showcase.
+ *
+ * Builds a minimal compose flow that:
+ * - StaticCalls `IPool.getUserAccountData(user)` on Aave v3 (Base)
+ * - Decomposes the returned 6-tuple via the EXPLODE opcode
+ * - Asserts `healthFactor >= 1.0 WAD` via `core.numericInvariant`
+ *
+ * The signer must hold an Aave v3 position on the target chain so HF > 0.
+ * Uses `allow-revert` so the compiled calldata is returned even if the
+ * assertion would fail — handy for tracing on a fork.
+ */
+export const buildAaveHealthFactorExplode = ({
+  signer,
+}: AaveHealthFactorExplodeInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(8453 /* Base */, {
+    name: 'aave-hf-explode-showcase',
+    inputs: {},
+  });
+
+  builder.aave.getHealthFactor('checkHf', {
+    bind: {},
+    config: { pool: AAVE_V3_POOL, user: signer },
+    guards: [
+      guards.coreNumericInvariant({
+        port: 'healthFactor',
+        op: 'gte',
+        threshold: MIN_HEALTH_FACTOR_WAD,
+      }),
+    ],
+  });
+
+  const flow = builder.build();
+  const request = sdk.request(flow, {
+    signer,
+    inputs: {},
+    simulationPolicy: 'allow-revert',
+  });
+
+  return { flow, request };
+};

package/src/examples/morphoBlueBorrow.ts

@@ -0,0 +1,94 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, materialisers, resources } from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Morpho Blue WETH/USDC market on Base (chainId 8453).
+// The Morpho singleton address (0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb)
+// is the default `morpho` config field and is read from compose-builtins.
+const ADAPTIVE_CURVE_IRM_BASE = '0x46415998764C29aB2a25CbeA6254146D50D22687';
+const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+const BASE_WETH = '0x4200000000000000000000000000000000000006';
+const WETH_USDC_ORACLE = '0xFEa2D58cEfCb9fcb597723c6bAE66fFE4193aFE4';
+const WETH_USDC_LLTV = '860000000000000000'; // 0.86e18
+
+const WETH_USDC_MARKET = {
+  loanToken: BASE_USDC,
+  collateralToken: BASE_WETH,
+  oracle: WETH_USDC_ORACLE,
+  irm: ADAPTIVE_CURVE_IRM_BASE,
+  lltv: WETH_USDC_LLTV,
+};
+
+export interface MorphoBlueBorrowInput {
+  readonly owner: Address;
+  readonly collateralAmount: `${bigint}`;
+  readonly borrowAmount: `${bigint}`;
+}
+
+/**
+ * Open a leveraged-borrow position on the Base Morpho Blue WETH/USDC market.
+ *
+ * - `morphoBlue.supplyCollateral` debits the proxy's WETH and credits
+ *   `Morpho.position(WETH_USDC_MARKET_ID, proxy).collateral`. There is no
+ *   receipt token — collateral is non-transferable accounting state.
+ * - `morphoBlue.borrow` mints debt shares against that collateral and
+ *   transfers USDC to the proxy. The borrowed asset is exposed as the
+ *   `borrowed` Resource port for downstream nodes.
+ * - The flow sweeps the borrowed USDC back to the signer's wallet via
+ *   `sweepTo` on the request.
+ */
+export const buildMorphoBlueBorrow = ({
+  owner,
+  collateralAmount,
+  borrowAmount,
+}: MorphoBlueBorrowInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(8453, {
+    name: 'morpho-blue-borrow-weth-usdc',
+    inputs: {
+      assetIn: resources.erc20(BASE_WETH, 8453),
+    },
+  });
+
+  builder.morphoBlue.supplyCollateral('supply-collateral', {
+    bind: {
+      assetIn: builder.inputs.assetIn,
+    },
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      mode: 'exact',
+    },
+  });
+
+  builder.morphoBlue.borrow('borrow', {
+    bind: {},
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      amount: borrowAmount,
+    },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      assetIn: materialisers.directDeposit({ amount: collateralAmount }),
+    },
+    // Sweep the borrowed USDC back to the signer.
+    sweepTo: builder.context.sender,
+    // The WETH collateral becomes unpriced Morpho position state (no receipt
+    // token), so the default 500 bps price-impact check reads any safe borrow
+    // (LLTV caps at 86%) as a loss. 0 skips the check.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};

package/src/examples/morphoBlueRepay.ts

@@ -0,0 +1,133 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, materialisers, resources } from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Morpho Blue WETH/USDC market on Base (chainId 8453).
+const ADAPTIVE_CURVE_IRM_BASE = '0x46415998764C29aB2a25CbeA6254146D50D22687';
+const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+const BASE_WETH = '0x4200000000000000000000000000000000000006';
+const WETH_USDC_ORACLE = '0xFEa2D58cEfCb9fcb597723c6bAE66fFE4193aFE4';
+const WETH_USDC_LLTV = '860000000000000000';
+
+const WETH_USDC_MARKET = {
+  loanToken: BASE_USDC,
+  collateralToken: BASE_WETH,
+  oracle: WETH_USDC_ORACLE,
+  irm: ADAPTIVE_CURVE_IRM_BASE,
+  lltv: WETH_USDC_LLTV,
+};
+
+export interface MorphoBlueRepayInput {
+  readonly owner: Address;
+  /** WETH supplied as collateral for the in-flow borrow (18 dp). */
+  readonly collateralAmount: `${bigint}`;
+  /** USDC borrowed against the collateral, then repaid by this flow (6 dp). */
+  readonly borrowAmount: `${bigint}`;
+  /**
+   * USDC deposited to repay the debt (6 dp). Must exceed `borrowAmount`:
+   * Morpho's share rounding can leave the debt a wei above the borrowed
+   * amount, so the `max`-mode repay needs a little headroom. The leftover
+   * surfaces on the `residual` port.
+   */
+  readonly repayAmount: `${bigint}`;
+}
+
+/**
+ * Open and close a Morpho Blue WETH/USDC position on Base in one flow —
+ * a self-contained supplyCollateral → borrow → repay → withdrawCollateral
+ * round trip that creates the debt it retires.
+ *
+ * Demonstrates:
+ * - `morphoBlue.supplyCollateral` to post WETH (collateral is internal
+ *   position state — no receipt token).
+ * - `morphoBlue.borrow` to mint USDC debt against it.
+ * - `morphoBlue.repay` with `mode: 'max'`, which reads the proxy's current
+ *   `borrowShares` on-chain and repays in shares mode to retire the debt to
+ *   the wei. Unused USDC surfaces on the `residual` Resource port.
+ * - `morphoBlue.withdrawCollateral` to pull the freed WETH once the debt
+ *   is cleared.
+ * - `sweepTo` to return the borrowed USDC, the repay residual, and the
+ *   freed WETH to the signer.
+ */
+export const buildMorphoBlueRepay = ({
+  owner,
+  collateralAmount,
+  borrowAmount,
+  repayAmount,
+}: MorphoBlueRepayInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(8453, {
+    name: 'morpho-blue-repay-usdc-withdraw-weth',
+    inputs: {
+      collateralIn: resources.erc20(BASE_WETH, 8453),
+      repayIn: resources.erc20(BASE_USDC, 8453),
+    },
+  });
+
+  // Post WETH collateral so the proxy can open the debt it will repay.
+  builder.morphoBlue.supplyCollateral('supply-collateral', {
+    bind: {
+      assetIn: builder.inputs.collateralIn,
+    },
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      mode: 'exact',
+    },
+  });
+
+  // Borrow USDC against the collateral; the borrowed USDC stays on the
+  // proxy as a terminal resource and is swept back to the signer.
+  builder.morphoBlue.borrow('borrow', {
+    bind: {},
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      amount: borrowAmount,
+    },
+  });
+
+  // Retire the just-opened debt from the deposited USDC. mode 'max' reads
+  // the live borrowShares and repays in shares mode, clearing the debt to
+  // the wei; the unused USDC surfaces on the `residual` port.
+  builder.morphoBlue.repay('repay', {
+    bind: {
+      assetIn: builder.inputs.repayIn,
+      onBehalfOf: builder.context.executionAddress,
+    },
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      mode: 'max',
+    },
+  });
+
+  // The debt is cleared, so the full collateral can be withdrawn. The freed
+  // WETH lands on the proxy and is swept to the signer.
+  builder.morphoBlue.withdrawCollateral('withdraw-collateral', {
+    bind: {},
+    config: {
+      marketParams: WETH_USDC_MARKET,
+      amount: collateralAmount,
+    },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      collateralIn: materialisers.directDeposit({ amount: collateralAmount }),
+      repayIn: materialisers.directDeposit({ amount: repayAmount }),
+    },
+    // Sweep the borrowed USDC, the repay residual, and the freed WETH back
+    // to the signer.
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/run.ts

@@ -8,6 +8,8 @@
  *   LIFI_API_KEY=your-key COMPOSER_BASE_URL=https://composer.li.quest yarn example <name>
  *
  * Available examples:
+ *   aave-borrow       — supply USDC to Aave v3, borrow against it with a health-factor guard
+ *   aave-hf-explode   — read the Aave v3 health factor and assert it stays >= 1.0
  *   aave-repay        — repay an Aave v3 WETH debt by supplying WETH
  *   aave-repay-atoken — repay an Aave v3 USDC debt by burning proxy aTokens
  *   aave-emode        — switch the proxy's Aave v3 eMode category
@@ -21,6 +23,8 @@
  *   split-arithmetic  — split USDC 70/30 with arithmetic assertions
  *   zap               — zap USDC into Aave lending position
  *   zap-async         — zap USDC into an async Aave position (future output)
+ *   morpho-borrow     — supply WETH collateral to Morpho Blue and borrow USDC
+ *   morpho-repay      — open, repay and close a Morpho Blue WETH/USDC position
  *   fly-swap          — exit a Pendle PT position and swap ALL proceeds to WETH
  *   swap-zap          — swap WETH to USDC then zap into Aave
  *   swap-check        — swap WETH to USDC with balance check
@@ -34,6 +38,8 @@
  *   transfer          — transfer full token balance to a recipient
  *   partial-transfer  — transfer a specific amount, keeping the remainder
  *   untyped-ref       — mix untypedOp with typed handles via raw.ref
+ *   uniswap-v2-add    — split USDC, swap half to WETH, add both to the Uniswap V2 pair
+ *   uniswap-v3-mint   — open a full-range Uniswap V3 USDC/WETH position
  *   route-exact       — wrap 0.1 native ETH into WETH via /compose/route
  *   route-all         — unwrap the whole WETH balance to ETH via /compose/route
  *   supported-chains  — list the chains this deployment supports, and guard on them
@@ -46,6 +52,8 @@ import type {
 import { bigintReplacer } from '../client.js';
 import { type ComposeSdk, createComposeSdk } from '../sdk.js';
 
+import { buildAaveBorrow } from './aaveBorrow.js';
+import { buildAaveHealthFactorExplode } from './aaveHealthFactorExplode.js';
 import { buildAaveRepay } from './aaveRepay.js';
 import { buildAaveRepayWithATokens } from './aaveRepayWithATokens.js';
 import { buildAaveSetEMode } from './aaveSetEMode.js';
@@ -60,6 +68,8 @@ import { buildFlySwapExample } from './flySwap.js';
 import { buildLifiSwapExample } from './lifiSwap.js';
 import { buildLifiZapExample } from './lifiZap.js';
 import { buildLifiZapAsyncExample } from './lifiZapAsync.js';
+import { buildMorphoBlueBorrow } from './morphoBlueBorrow.js';
+import { buildMorphoBlueRepay } from './morphoBlueRepay.js';
 import { buildRawCallWithArithmetic } from './rawCallWithArithmetic.js';
 import { buildReadContractState } from './readContractState.js';
 import {
@@ -75,12 +85,23 @@ import { buildSwapWithAllowRevertExample } from './swapWithAllowRevert.js';
 import { buildSwapWithBalanceCheck } from './swapWithBalanceCheck.js';
 import { buildSwapWithOutputValidation } from './swapWithOutputValidation.js';
 import { buildPartialTransfer, buildTransferTokens } from './transferTokens.js';
+import { buildUniswapV2AddLiquidity } from './uniswapV2AddLiquidity.js';
+import { buildUniswapV3Mint } from './uniswapV3Mint.js';
 import { buildUntypedOpWithTypedRef } from './untypedOpWithTypedRef.js';
 
 const stringifyJson = (value: unknown) =>
   JSON.stringify(value, bigintReplacer, 2);
 
 const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
+  'aave-borrow': () =>
+    buildAaveBorrow({
+      owner: OWNER,
+      recipient: RECIPIENT,
+      collateralAmount: '1000000000',
+      borrowAmount: '500000000',
+    }).request,
+  'aave-hf-explode': () =>
+    buildAaveHealthFactorExplode({ signer: OWNER }).request,
   'aave-repay': () =>
     buildAaveRepay({
       owner: OWNER,
@@ -128,6 +149,19 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
   'zap-async': () =>
     buildLifiZapAsyncExample({ owner: OWNER, recipient: RECIPIENT }).request,
   'fly-swap': () => buildFlySwapExample().request,
+  'morpho-borrow': () =>
+    buildMorphoBlueBorrow({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      borrowAmount: '1200000000',
+    }).request,
+  'morpho-repay': () =>
+    buildMorphoBlueRepay({
+      owner: OWNER,
+      collateralAmount: '1000000000000000000',
+      borrowAmount: '500000000',
+      repayAmount: '501000000',
+    }).request,
   'swap-zap': () => buildSwapAndZapExample().request,
   'swap-check': () =>
     buildSwapWithBalanceCheck({ owner: OWNER, amount: '1000000000000000000' })
@@ -166,6 +200,15 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
       amount: '1000000000',
     }).request,
   'untyped-ref': () => buildUntypedOpWithTypedRef({ owner: OWNER }).request,
+  'uniswap-v2-add': () =>
+    buildUniswapV2AddLiquidity({ owner: OWNER, usdcAmount: '1000000000' })
+      .request,
+  'uniswap-v3-mint': () =>
+    buildUniswapV3Mint({
+      owner: OWNER,
+      usdcAmount: '1000000000',
+      wethAmount: '400000000000000000',
+    }).request,
 };
 
 // `/compose/route` examples build a `ComposeRouteRequest` and go to

package/src/examples/uniswapV2AddLiquidity.ts

@@ -0,0 +1,106 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  createComposeSdk,
+  guards,
+  materialisers,
+  resources,
+} from '../index.js';
+import type { Address } from '../types.js';
+
+import { API_KEY, BASE_URL } from './config.js';
+
+// Ethereum mainnet (chainId 1).
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const UNISWAP_V2_ROUTER = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D';
+const UNISWAP_V2_FACTORY = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f';
+const USDC_WETH_PAIR = '0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc';
+
+// Tolerance of the swap leg: the aggregator's `toAmountMin` lets the swap
+// deliver up to 3% less WETH than quoted.
+const SWAP_SLIPPAGE = 0.03;
+
+export interface UniswapV2AddLiquidityInput {
+  readonly owner: Address;
+  readonly usdcAmount: `${bigint}`;
+}
+
+/**
+ * Deposit USDC alone into the Uniswap V2 USDC/WETH pair.
+ *
+ * - `core.split` halves the USDC input.
+ * - `lifi.swap` turns one half into WETH.
+ * - `uniswapV2.addLiquidity` deposits the other USDC half and the swapped
+ *   WETH, minting the UNI-V2 LP token. Unused input comes back as residuals.
+ * - The request sweeps the LP token and the residuals to the signer.
+ */
+export const buildUniswapV2AddLiquidity = ({
+  owner,
+  usdcAmount,
+}: UniswapV2AddLiquidityInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(1, {
+    name: 'uniswap-v2-add-liquidity-usdc-weth',
+    inputs: {
+      usdcIn: resources.erc20(USDC, 1),
+    },
+  });
+
+  const { a: usdcHalf, b: usdcToSwap } = builder.core.split('split', {
+    bind: { source: builder.inputs.usdcIn },
+    config: { bps: 5000 },
+  });
+
+  const swap = builder.lifi.swap('swap', {
+    bind: { amountIn: usdcToSwap },
+    config: {
+      resourceOut: resources.erc20(WETH, 1),
+      slippage: SWAP_SLIPPAGE,
+    },
+  });
+
+  builder.uniswapV2.addLiquidity('add-liquidity', {
+    bind: {
+      tokenA: usdcHalf,
+      tokenB: swap.amountOut,
+    },
+    config: {
+      router: UNISWAP_V2_ROUTER,
+      factory: UNISWAP_V2_FACTORY,
+      pair: USDC_WETH_PAIR,
+    },
+    guards: [
+      // The router is called with zero minimums, so this band is the sandwich
+      // protection: it reverts unless the pool price read before the deposit
+      // stays within ±50 bps of the simulated price. It does not depend on the
+      // swap leg.
+      guards.band({ port: 'poolPrice', bps: 50 }),
+      // A swap that fills at its 3% minimum delivers less WETH, so the add
+      // mints less LP. The floor must cover that tolerance (300 bps) plus the
+      // 50 bps band, or a valid swap fill reverts the transaction.
+      guards.slippage({ port: 'liquidity', bps: 350 }),
+    ],
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      usdcIn: materialisers.directDeposit({ amount: usdcAmount }),
+    },
+    // Sweep the LP token and the unused USDC/WETH back to the signer.
+    sweepTo: builder.context.sender,
+    // The UNI-V2 LP token is unpriced, so the default 500 bps price-impact
+    // check reads the deposit as a 100% loss. 0 skips the check; the `band`
+    // and `slippage` guards above are the protection.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};