@lifi/composer-sdk 0.7.0 → 0.8.1

package/src/examples/uniswapV3Mint.ts

@@ -0,0 +1,95 @@
+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';
+
+// Uniswap V3 USDC/WETH 0.05% pool on Ethereum mainnet (chainId 1).
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const POSITION_MANAGER = '0xC36442b4a4522E871399CD717aBDD847Ab11FE88';
+const FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+const USDC_WETH_500_POOL = '0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640';
+// Full range: the widest ticks that are multiples of the pool's tick spacing (10).
+const TICK_LOWER = -887270;
+const TICK_UPPER = 887270;
+
+export interface UniswapV3MintInput {
+  readonly owner: Address;
+  readonly usdcAmount: `${bigint}`;
+  readonly wethAmount: `${bigint}`;
+}
+
+/**
+ * Open a full-range Uniswap V3 USDC/WETH position on Ethereum mainnet.
+ *
+ * - `uniswapV3.mint` deposits the proxy's USDC and WETH and mints the
+ *   position NFT straight to the signer.
+ * - Unused USDC or WETH comes back as residuals, swept to the signer.
+ */
+export const buildUniswapV3Mint = ({
+  owner,
+  usdcAmount,
+  wethAmount,
+}: UniswapV3MintInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(1, {
+    name: 'uniswap-v3-mint-usdc-weth',
+    inputs: {
+      usdc: resources.erc20(USDC, 1),
+      weth: resources.erc20(WETH, 1),
+    },
+  });
+
+  builder.uniswapV3.mint('mint', {
+    bind: {
+      tokenA: builder.inputs.usdc,
+      tokenB: builder.inputs.weth,
+      recipient: builder.context.sender,
+    },
+    config: {
+      positionManager: POSITION_MANAGER,
+      factory: FACTORY,
+      pool: USDC_WETH_500_POOL,
+      fee: 500,
+      tickLower: TICK_LOWER,
+      tickUpper: TICK_UPPER,
+    },
+    guards: [
+      // Bound the pool price before the deposit; N bps on the sqrt price
+      // allows about 2N bps of price movement, so this caps it near 50 bps.
+      guards.band({ port: 'sqrtPriceX96', bps: 25 }),
+      // Floor the minted liquidity. Liquidity is a handle, not a resource,
+      // so no minimum appears in the response.
+      guards.slippage({ port: 'liquidity', bps: 50 }),
+    ],
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      usdc: materialisers.directDeposit({ amount: usdcAmount }),
+      weth: materialisers.directDeposit({ amount: wethAmount }),
+    },
+    // Return unused USDC or WETH to the signer.
+    sweepTo: builder.context.sender,
+    // The position NFT is not a resource, so only the residuals count as
+    // output and the default price-impact check would read a full loss.
+    // 0 skips the check; the band and slippage guards protect the deposit.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};

package/src/generated/config.generated.ts

@@ -1170,44 +1170,6 @@ export interface LifiFlashloanRepayConfig {
   fee?: string;
 }
 
-export type ContinuationAssertReadyConfig =
-  | {
-      kind: 'erc20BalanceGte';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      token: Address;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      owner: Address;
-      minAmount: string;
-    }
-  | {
-      kind: 'nativeBalanceGte';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      owner: Address;
-      minAmount: string;
-    }
-  | {
-      kind: 'call';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      to: string;
-      /**
-       * Hex bytes: 0x followed by an even number of hex characters
-       */
-      calldata: string;
-      comparator: 'gte' | 'eq' | 'lte';
-      value: string;
-    };
-
 export interface LifiZapConfig {
   resourceOut:
     | {
@@ -1305,6 +1267,83 @@ export interface FlySwapConfig {
   maxSlippageBps?: Between05000;
 }
 
+export interface UniswapV2AddLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  router: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pair: string;
+}
+
+export interface UniswapV2RemoveLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  router: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  tokenA: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  tokenB: string;
+}
+
+/**
+ * a number between 0 and 999999
+ */
+export type Between0999999 = number;
+/**
+ * a number between -887272 and 887272
+ */
+export type Between887272887272 = number;
+
+export interface UniswapV3MintConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  positionManager: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pool: string;
+  fee: Between0999999;
+  tickLower: Between887272887272;
+  tickUpper: Between887272887272;
+}
+
+export interface UniswapV3IncreaseLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  positionManager: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pool: string;
+  tokenId: string;
+}
+
 export interface SlippageGuardConfig {
   port: string;
   bps: Between010000;
@@ -1316,6 +1355,11 @@ export interface CoreNumericInvariantGuardConfig {
   threshold: IntegerStringInput;
 }
 
+export interface BandGuardConfig {
+  port: string;
+  bps: Between010000;
+}
+
 export interface BalanceOfMaterialiserConfig {
   /**
    * EVM address: 0x followed by 40 hex characters

package/src/generated/guards.generated.ts

@@ -4,6 +4,7 @@
 import type { TypedGuard } from '../types.js';
 
 import type {
+  BandGuardConfig,
   CoreNumericInvariantGuardConfig,
   SlippageGuardConfig,
 } from './config.generated.js';
@@ -23,3 +24,11 @@ export const coreNumericInvariant = <P extends string>(
   kind: 'core.numericInvariant',
   ...config,
 });
+
+/** Assert that an output stays within a tolerance in basis points of its simulated value, in both directions */
+export const band = <P extends string>(
+  config: Omit<BandGuardConfig, 'port'> & { port: P },
+): TypedGuard<P> => ({
+  kind: 'band',
+  ...config,
+});

package/src/generated/operations.generated.ts

@@ -23,6 +23,7 @@ import type { TypedGuard } from '../types.js';
 import type {
   AaveBorrowConfig,
   AaveClaimRewardsConfig,
+  AaveGetHealthFactorConfig,
   AaveRepayConfig,
   AaveRepayWithATokensConfig,
   AaveSetEModeConfig,
@@ -55,9 +56,18 @@ import type {
   LifiSwapConfig,
   LifiZapAsyncConfig,
   LifiZapConfig,
+  MorphoBlueBorrowConfig,
+  MorphoBlueGetPositionConfig,
+  MorphoBlueRepayConfig,
   MorphoBlueSupplyCollateralConfig,
+  MorphoBlueSupplyConfig,
   MorphoBlueWithdrawCollateralConfig,
+  MorphoBlueWithdrawConfig,
   ParaswapBuyConfig,
+  UniswapV2AddLiquidityConfig,
+  UniswapV2RemoveLiquidityConfig,
+  UniswapV3IncreaseLiquidityConfig,
+  UniswapV3MintConfig,
 } from './config.generated.js';
 
 /** Split a resource into two outputs by basis-point ratio. Output `a` receives `bps` of the source, rounded up, and `b` takes the remainder. */
@@ -532,6 +542,13 @@ export interface AaveSetEModeArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
+/** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. */
+export interface AaveGetHealthFactorArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveGetHealthFactorConfig;
+  readonly guards?: readonly TypedGuard<'healthFactor'>[];
+}
+
 /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). */
 export interface MorphoBlueSupplyCollateralArgs {
   readonly bind: {
@@ -548,6 +565,54 @@ export interface MorphoBlueWithdrawCollateralArgs {
   readonly guards?: readonly TypedGuard<'collateralWithdrawn'>[];
 }
 
+/** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. */
+export interface MorphoBlueBorrowArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueBorrowConfig;
+  readonly guards?: readonly TypedGuard<'assetsBorrowed' | 'sharesBorrowed'>[];
+}
+
+/** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. */
+export interface MorphoBlueRepayArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+    readonly onBehalfOf: Bindable<'address'>;
+  };
+  readonly config: MorphoBlueRepayConfig;
+  readonly guards?: readonly TypedGuard<
+    'actualRepaid' | 'sharesRepaid' | 'residual'
+  >[];
+}
+
+/** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. */
+export interface MorphoBlueSupplyArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+  };
+  readonly config: MorphoBlueSupplyConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsSupplied' | 'sharesSupplied' | 'residual'
+  >[];
+}
+
+/** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. */
+export interface MorphoBlueWithdrawArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueWithdrawConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsWithdrawn' | 'sharesWithdrawn'
+  >[];
+}
+
+/** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). */
+export interface MorphoBlueGetPositionArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueGetPositionConfig;
+  readonly guards?: readonly TypedGuard<
+    'supplyShares' | 'borrowShares' | 'collateral'
+  >[];
+}
+
 /** Route tokens into a DeFi protocol position via the edge catalog */
 export interface LifiZapArgs {
   readonly bind: {
@@ -593,6 +658,53 @@ export interface FlySwapArgs {
   readonly guards?: readonly TypedGuard<'unspentIn'>[];
 }
 
+/** Deposit two ERC-20 tokens into an existing Uniswap V2 pair (or an ABI-identical fork such as SushiSwap V2) through its Router02 and receive the pair's LP token; unused input returns as residuals. Asserts on chain that the router's factory is `factory`, that the factory's pair for the two tokens is `pair`, and that the pair holds non-zero reserves. Exposes the pool price read before the deposit as `poolPrice`. The deposit is protected only with a `band` guard on `poolPrice` and a `slippage` guard on `liquidity`. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV2AddLiquidityArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+  };
+  readonly config: UniswapV2AddLiquidityConfig;
+  readonly guards?: readonly TypedGuard<
+    'liquidity' | 'residualA' | 'residualB' | 'poolPrice'
+  >[];
+}
+
+/** Burn a Uniswap V2 LP token (or one of an ABI-identical fork such as SushiSwap V2) through its Router02 and receive both underlying tokens. Asserts on chain that the router's factory is `factory` and that the factory's pair for `tokenA`/`tokenB` is the input LP token. The withdrawal is protected only with a `slippage` guard on each of `tokenA` and `tokenB`. Fee-on-transfer tokens are unsupported: the outputs are the amounts the router reports, which would overstate what such a token delivers. */
+export interface UniswapV2RemoveLiquidityArgs {
+  readonly bind: {
+    readonly liquidity: Bindable<'resource'>;
+  };
+  readonly config: UniswapV2RemoveLiquidityConfig;
+  readonly guards?: readonly TypedGuard<'tokenA' | 'tokenB'>[];
+}
+
+/** Open a Uniswap V3 concentrated-liquidity position (or one on an ABI-identical fork) for a tick range, minting the position NFT straight to `recipient`, which must not be the execution address. Exposes the new `tokenId`; unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV3MintArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+    readonly recipient: Bindable<'address'>;
+  };
+  readonly config: UniswapV3MintConfig;
+  readonly guards?: readonly TypedGuard<
+    'tokenId' | 'liquidity' | 'sqrtPriceX96' | 'residualA' | 'residualB'
+  >[];
+}
+
+/** Add two tokens to an existing Uniswap V3 position (or one on an ABI-identical fork). `owner` must own `tokenId`, and the position must hold the two input tokens; both are asserted on chain, since the position manager checks neither. Unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV3IncreaseLiquidityArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+  };
+  readonly config: UniswapV3IncreaseLiquidityConfig;
+  readonly guards?: readonly TypedGuard<
+    'liquidity' | 'sqrtPriceX96' | 'residualA' | 'residualB'
+  >[];
+}
+
 export interface CoreSplitOutputs {
   readonly a: OutputHandle<'resource'>;
   readonly b: OutputHandle<'resource'>;
@@ -685,11 +797,45 @@ export interface AaveClaimRewardsOutputs {
   readonly claimedAmount: OutputHandle<'uint256'>;
 }
 
+export interface AaveGetHealthFactorOutputs {
+  readonly healthFactor: OutputHandle<'uint256'>;
+}
+
 export interface MorphoBlueWithdrawCollateralOutputs {
   readonly withdrawn: OutputHandle<'resource'>;
   readonly collateralWithdrawn: OutputHandle<'uint256'>;
 }
 
+export interface MorphoBlueBorrowOutputs {
+  readonly borrowed: OutputHandle<'resource'>;
+  readonly assetsBorrowed: OutputHandle<'uint256'>;
+  readonly sharesBorrowed: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueRepayOutputs {
+  readonly actualRepaid: OutputHandle<'uint256'>;
+  readonly sharesRepaid: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueSupplyOutputs {
+  readonly assetsSupplied: OutputHandle<'uint256'>;
+  readonly sharesSupplied: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueWithdrawOutputs {
+  readonly withdrawn: OutputHandle<'resource'>;
+  readonly assetsWithdrawn: OutputHandle<'uint256'>;
+  readonly sharesWithdrawn: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueGetPositionOutputs {
+  readonly supplyShares: OutputHandle<'uint256'>;
+  readonly borrowShares: OutputHandle<'uint128'>;
+  readonly collateral: OutputHandle<'uint128'>;
+}
+
 export interface LifiZapOutputs {
   readonly amountOut: OutputHandle<'resource'>;
 }
@@ -712,6 +858,33 @@ export interface FlySwapOutputs {
   readonly unspentIn: OutputHandle<'resource'>;
 }
 
+export interface UniswapV2AddLiquidityOutputs {
+  readonly liquidity: OutputHandle<'resource'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+  readonly poolPrice: OutputHandle<'uint256'>;
+}
+
+export interface UniswapV2RemoveLiquidityOutputs {
+  readonly tokenA: OutputHandle<'resource'>;
+  readonly tokenB: OutputHandle<'resource'>;
+}
+
+export interface UniswapV3MintOutputs {
+  readonly tokenId: OutputHandle<'uint256'>;
+  readonly liquidity: OutputHandle<'uint256'>;
+  readonly sqrtPriceX96: OutputHandle<'uint256'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+}
+
+export interface UniswapV3IncreaseLiquidityOutputs {
+  readonly liquidity: OutputHandle<'uint256'>;
+  readonly sqrtPriceX96: OutputHandle<'uint256'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+}
+
 export type GeneratedOps = {
   readonly core: {
     /** Split a resource into two outputs by basis-point ratio. Output `a` receives `bps` of the source, rounded up, and `b` takes the remainder. — original id: "core.split" */
@@ -914,6 +1087,11 @@ export type GeneratedOps = {
     ) => AaveClaimRewardsOutputs;
     /** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. — original id: "aave.setEMode" */
     readonly setEMode: (nodeId: string, args: AaveSetEModeArgs) => void;
+    /** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. — original id: "aave.getHealthFactor" */
+    readonly getHealthFactor: (
+      nodeId: string,
+      args: AaveGetHealthFactorArgs,
+    ) => AaveGetHealthFactorOutputs;
   };
   readonly morphoBlue: {
     /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). — original id: "morphoBlue.supplyCollateral" */
@@ -926,6 +1104,31 @@ export type GeneratedOps = {
       nodeId: string,
       args: MorphoBlueWithdrawCollateralArgs,
     ) => MorphoBlueWithdrawCollateralOutputs;
+    /** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. — original id: "morphoBlue.borrow" */
+    readonly borrow: (
+      nodeId: string,
+      args: MorphoBlueBorrowArgs,
+    ) => MorphoBlueBorrowOutputs;
+    /** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. — original id: "morphoBlue.repay" */
+    readonly repay: (
+      nodeId: string,
+      args: MorphoBlueRepayArgs,
+    ) => MorphoBlueRepayOutputs;
+    /** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. — original id: "morphoBlue.supply" */
+    readonly supply: (
+      nodeId: string,
+      args: MorphoBlueSupplyArgs,
+    ) => MorphoBlueSupplyOutputs;
+    /** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. — original id: "morphoBlue.withdraw" */
+    readonly withdraw: (
+      nodeId: string,
+      args: MorphoBlueWithdrawArgs,
+    ) => MorphoBlueWithdrawOutputs;
+    /** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). — original id: "morphoBlue.getPosition" */
+    readonly getPosition: (
+      nodeId: string,
+      args: MorphoBlueGetPositionArgs,
+    ) => MorphoBlueGetPositionOutputs;
   };
   readonly paraswap: {
     /** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. — original id: "paraswap.buy" */
@@ -935,6 +1138,30 @@ export type GeneratedOps = {
     /** Swap via Fly's DexAggregator, sized at runtime: the router calldata leaves `amountIn` unset, so an upstream op's output can feed the swap without being known at plan time. Either leg may be the chain-native coin. — original id: "fly.swap" */
     readonly swap: (nodeId: string, args: FlySwapArgs) => FlySwapOutputs;
   };
+  readonly uniswapV2: {
+    /** Deposit two ERC-20 tokens into an existing Uniswap V2 pair (or an ABI-identical fork such as SushiSwap V2) through its Router02 and receive the pair's LP token; unused input returns as residuals. Asserts on chain that the router's factory is `factory`, that the factory's pair for the two tokens is `pair`, and that the pair holds non-zero reserves. Exposes the pool price read before the deposit as `poolPrice`. The deposit is protected only with a `band` guard on `poolPrice` and a `slippage` guard on `liquidity`. Fee-on-transfer tokens are unsupported. — original id: "uniswapV2.addLiquidity" */
+    readonly addLiquidity: (
+      nodeId: string,
+      args: UniswapV2AddLiquidityArgs,
+    ) => UniswapV2AddLiquidityOutputs;
+    /** Burn a Uniswap V2 LP token (or one of an ABI-identical fork such as SushiSwap V2) through its Router02 and receive both underlying tokens. Asserts on chain that the router's factory is `factory` and that the factory's pair for `tokenA`/`tokenB` is the input LP token. The withdrawal is protected only with a `slippage` guard on each of `tokenA` and `tokenB`. Fee-on-transfer tokens are unsupported: the outputs are the amounts the router reports, which would overstate what such a token delivers. — original id: "uniswapV2.removeLiquidity" */
+    readonly removeLiquidity: (
+      nodeId: string,
+      args: UniswapV2RemoveLiquidityArgs,
+    ) => UniswapV2RemoveLiquidityOutputs;
+  };
+  readonly uniswapV3: {
+    /** Open a Uniswap V3 concentrated-liquidity position (or one on an ABI-identical fork) for a tick range, minting the position NFT straight to `recipient`, which must not be the execution address. Exposes the new `tokenId`; unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. — original id: "uniswapV3.mint" */
+    readonly mint: (
+      nodeId: string,
+      args: UniswapV3MintArgs,
+    ) => UniswapV3MintOutputs;
+    /** Add two tokens to an existing Uniswap V3 position (or one on an ABI-identical fork). `owner` must own `tokenId`, and the position must hold the two input tokens; both are asserted on chain, since the position manager checks neither. Unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. — original id: "uniswapV3.increaseLiquidity" */
+    readonly increaseLiquidity: (
+      nodeId: string,
+      args: UniswapV3IncreaseLiquidityArgs,
+    ) => UniswapV3IncreaseLiquidityOutputs;
+  };
 };
 
 export const bindGeneratedOps = (
@@ -1173,6 +1400,10 @@ export const bindGeneratedOps = (
       } as const),
     setEMode: (nodeId: string, args: AaveSetEModeArgs) =>
       builder.call(nodeId, 'aave.setEMode', args, {}),
+    getHealthFactor: (nodeId: string, args: AaveGetHealthFactorArgs) =>
+      builder.call(nodeId, 'aave.getHealthFactor', args, {
+        healthFactor: 'uint256',
+      } as const),
   },
   morphoBlue: {
     supplyCollateral: (nodeId: string, args: MorphoBlueSupplyCollateralArgs) =>
@@ -1185,6 +1416,36 @@ export const bindGeneratedOps = (
         withdrawn: 'resource',
         collateralWithdrawn: 'uint256',
       } as const),
+    borrow: (nodeId: string, args: MorphoBlueBorrowArgs) =>
+      builder.call(nodeId, 'morphoBlue.borrow', args, {
+        borrowed: 'resource',
+        assetsBorrowed: 'uint256',
+        sharesBorrowed: 'uint256',
+      } as const),
+    repay: (nodeId: string, args: MorphoBlueRepayArgs) =>
+      builder.call(nodeId, 'morphoBlue.repay', args, {
+        actualRepaid: 'uint256',
+        sharesRepaid: 'uint256',
+        residual: 'resource',
+      } as const),
+    supply: (nodeId: string, args: MorphoBlueSupplyArgs) =>
+      builder.call(nodeId, 'morphoBlue.supply', args, {
+        assetsSupplied: 'uint256',
+        sharesSupplied: 'uint256',
+        residual: 'resource',
+      } as const),
+    withdraw: (nodeId: string, args: MorphoBlueWithdrawArgs) =>
+      builder.call(nodeId, 'morphoBlue.withdraw', args, {
+        withdrawn: 'resource',
+        assetsWithdrawn: 'uint256',
+        sharesWithdrawn: 'uint256',
+      } as const),
+    getPosition: (nodeId: string, args: MorphoBlueGetPositionArgs) =>
+      builder.call(nodeId, 'morphoBlue.getPosition', args, {
+        supplyShares: 'uint256',
+        borrowShares: 'uint128',
+        collateral: 'uint128',
+      } as const),
   },
   paraswap: {
     buy: (nodeId: string, args: ParaswapBuyArgs) =>
@@ -1200,4 +1461,35 @@ export const bindGeneratedOps = (
         unspentIn: 'resource',
       } as const),
   },
+  uniswapV2: {
+    addLiquidity: (nodeId: string, args: UniswapV2AddLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV2.addLiquidity', args, {
+        liquidity: 'resource',
+        residualA: 'resource',
+        residualB: 'resource',
+        poolPrice: 'uint256',
+      } as const),
+    removeLiquidity: (nodeId: string, args: UniswapV2RemoveLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV2.removeLiquidity', args, {
+        tokenA: 'resource',
+        tokenB: 'resource',
+      } as const),
+  },
+  uniswapV3: {
+    mint: (nodeId: string, args: UniswapV3MintArgs) =>
+      builder.call(nodeId, 'uniswapV3.mint', args, {
+        tokenId: 'uint256',
+        liquidity: 'uint256',
+        sqrtPriceX96: 'uint256',
+        residualA: 'resource',
+        residualB: 'resource',
+      } as const),
+    increaseLiquidity: (nodeId: string, args: UniswapV3IncreaseLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV3.increaseLiquidity', args, {
+        liquidity: 'uint256',
+        sqrtPriceX96: 'uint256',
+        residualA: 'resource',
+        residualB: 'resource',
+      } as const),
+  },
 });

package/src/index.ts

@@ -99,11 +99,8 @@ export type {
   Erc20AllowanceRequirement,
   ContinuationIntent,
   ContinuationOutcome,
-  Check,
-  CheckComparator,
   SettlementWire,
   SettlementEscrowWire,
-  ContinuationPlanWire,
 } from '@lifi/compose-spec';
 export {
   SIMULATE_MAX_TRACKED_BALANCES,