@lifi/composer-sdk 0.7.0 → 0.7.1

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
@@ -46,6 +50,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 +66,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 {
@@ -81,6 +89,15 @@ 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 +145,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' })

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,8 +56,13 @@ import type {
   LifiSwapConfig,
   LifiZapAsyncConfig,
   LifiZapConfig,
+  MorphoBlueBorrowConfig,
+  MorphoBlueGetPositionConfig,
+  MorphoBlueRepayConfig,
   MorphoBlueSupplyCollateralConfig,
+  MorphoBlueSupplyConfig,
   MorphoBlueWithdrawCollateralConfig,
+  MorphoBlueWithdrawConfig,
   ParaswapBuyConfig,
 } from './config.generated.js';
 
@@ -532,6 +538,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 +561,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: {
@@ -685,11 +746,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'>;
 }
@@ -914,6 +1009,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 +1026,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" */
@@ -1173,6 +1298,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 +1314,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) =>