@lifi/composer-sdk
Version:
Public Composer SDK for building and submitting flows
345 lines (315 loc) • 14.6 kB
text/typescript
import {
type ComposeCompileRequest,
flashloanMaxFee,
type Flow,
} from '@lifi/compose-spec';
import {
createComposeSdk,
type FlowBuilder,
type InputSchema,
materialisers,
resources,
} from '../../index.js';
import type { Address } from '../../types.js';
import { AAVE_SAME_BLOCK_SKEW_WEI } from '../aaveRounding.js';
import { API_KEY, BASE_URL } from '../config.js';
// Base mainnet token addresses.
const BASE_WETH = '0x4200000000000000000000000000000000000006';
const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
// Circle EURC on Base (6 decimals).
const BASE_EURC = '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42';
// Token decimals for the Paraswap BUY (raw-address requests require them).
const EURC_DECIMALS = 6;
const USDC_DECIMALS = 6;
// Aave V3 on Base (pool + aWETH receipt + variable-debt USDC).
const AAVE_V3_POOL_BASE = '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5';
const A_BAS_WETH = '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7';
const VDEBT_BAS_USDC = '0x59dca05b6c26dbd64b5381374aAaC5CD05644C28';
// Morpho Blue WETH/EURC market on Base. Real listed market — borrow APY
// ~1.02% at the time of writing vs ~5.30% on the WETH/USDC market, which is
// what makes this migration economically interesting. Market ID:
// 0xa9b5142fa687a24c275faf731f13b52faa9873252bb4e1cb6077aa1f412edb0b
// (= keccak256(MarketParams) of the values below).
const ADAPTIVE_CURVE_IRM_BASE = '0x46415998764C29aB2a25CbeA6254146D50D22687';
const WETH_EURC_ORACLE = '0xE1bb8E5b4930eC9FeC7f7943FCF6227649F14B37';
const WETH_EURC_LLTV = '860000000000000000';
const MORPHO_WETH_EURC_MARKET = {
loanToken: BASE_EURC,
collateralToken: BASE_WETH,
oracle: WETH_EURC_ORACLE,
irm: ADAPTIVE_CURVE_IRM_BASE,
lltv: WETH_EURC_LLTV,
};
// Source-cap slippage on the EURC → USDC BUY, in basis points. This bounds how
// much extra EURC Augustus may pull above the quoted source before refunding.
// `morphoBorrowAmount` must exceed the resulting `maxAmountIn`.
const DEFAULT_MAX_SLIPPAGE_BPS = 100; // 1%
/**
* Forward the proxy's USDC above the leg's `reserve` to the signer. The live
* USDC balance holds the loan proceeds, the BUY output and the repay's
* leftover; the reserve must stay in the proxy for the runtime to repay Aave.
* The split keeps `min(balance, reserve)` as its head and pays out only the
* tail.
*
* A request-level `sweepTo` cannot do this: `outputs` reports the unbound
* `borrowed` and `residual` ports in full, but the sweep withholds the
* reserve, so it moves less than they report and compose rejects the flow.
*/
const payOutUsdcAboveReserve = <T extends InputSchema>(
builder: FlowBuilder<T>,
reserve: `${bigint}`,
): void => {
const usdcBalance = builder.core.balanceOf('read-usdc-balance', {
bind: {},
config: { token: BASE_USDC },
});
const { tail: usdcProceeds } = builder.core.splitAt(
'exclude-flashloan-reserve',
{
bind: { source: usdcBalance.balance },
config: { amount: reserve },
},
);
builder.core.transfer('payout-borrow-proceeds', {
bind: {
amount: usdcProceeds,
recipient: builder.context.sender,
},
config: {},
});
};
export interface AaveToMorphoDebtMigrationWithSwapExactOutInput {
readonly owner: Address;
/** WETH collateral the user posts (in smallest units, 18 decimals). */
readonly collateralAmount: `${bigint}`;
/** USDC principal borrowed from Aave (6 decimals). */
readonly debtAmount: `${bigint}`;
/**
* EURC to borrow from Morpho (6 decimals). Sized as a *generous upper bound*
* — large enough that the exact-output BUY can always produce
* `debtAmount + maxFee` USDC even after `maxSlippageBps` of source slippage
* (i.e. `morphoBorrowAmount > maxAmountIn`). The BUY pulls only what it needs;
* the unspent EURC is repaid straight back into the freshly-minted Morpho
* debt, so the *net* migrated debt is the original Aave debt (in EURC terms)
* plus only the slippage/fee actually consumed — NOT the full upper bound.
* Note: EUR/USD is not 1:1 — size off a live BUY quote, e.g.
* morphoBorrowAmount ≈ ceil((debtAmount + maxFee) * eurcPerUsdc * (1 + slippage))
*/
readonly morphoBorrowAmount: `${bigint}`;
/** Optional source-cap slippage on the BUY, in bps (default 100 = 1%). */
readonly maxSlippageBps?: number;
/** Optional integrator label for analytics / fee capture. */
readonly partner?: string;
/** Optional fee recipient; required to actually receive a partner fee. */
readonly partnerAddress?: Address;
/** Optional fixed partner fee in bps (e.g. '50' = 0.5%); needs partnerAddress. */
readonly partnerFeeBps?: string;
}
/**
* Atomically migrate an Aave V3 USDC borrow on Base into the Morpho Blue
* WETH/EURC market — same WETH collateral, different stablecoin debt — using a
* native **exact-output** (Paraswap/Velora BUY) swap instead of the exact-input
* `lifi.swap`.
*
* Contrast with `aaveToMorphoDebtMigrationWithSwap.ts` (the exact-input
* variant): there the author must over-size the Morpho borrow so a slippage-
* adjusted *minimum* output still clears the fixed flashloan need, and the
* buffer lands on the borrow leg as lasting debt. Here `paraswap.buy` produces
* *exactly* `debtAmount + maxFee` USDC, pulls only the EURC it needs, and the
* EURC it did not sell (Augustus's refund plus the headroom above the swap cap)
* stays on the proxy and is surfaced as `unspentIn` — which we route straight
* into a capped `morphoBlue.repay` to unwind the over-borrow. Net migrated
* debt = original debt + only the consumed slippage/fee, not a standing buffer.
*
* Phase 1 — provision the source position on Aave V3:
* - User direct-deposits WETH.
* - `lifi.zap` supplies the WETH to Aave (WETH → aBasWETH routing edge).
* - `aave.borrow` mints USDC debt; the borrowed USDC stays on the proxy
* until the payout at the end of the flow.
*
* Phase 2 — migrate to Morpho using two concurrent flashloans:
* - Flashloan #1 (Aave V3, USDC) bridges the Aave debt payoff.
* - Flashloan #2 (Balancer V2, WETH) bridges the Morpho collateral supply.
* - `aave.repay(mode: 'max')` clears the Aave USDC debt with flashloan #1.
* - `lifi.zap` withdraws the freed WETH from Aave (aBasWETH → WETH).
* - `morphoBlue.supplyCollateral` deposits flashloan #2's WETH into Morpho.
* - `morphoBlue.borrow` mints a *capped* `morphoBorrowAmount` of EURC.
* - `paraswap.buy` buys *exactly* `debtAmount + maxFee` USDC with the
* borrowed EURC. `amountOut` is the USDC leg's reserve (principal plus the
* fee cap); `unspentIn` is every borrowed EURC the swap did not sell,
* including the headroom above the swap cap.
* - Two `lifi.flashloanRepay` ops earmark each leg's funds: the USDC leg's from
* `buy.amountOut` (`amountOut` is the whole reserve), the WETH leg's from
* the Aave withdrawal (Balancer V2 charges no fee). They move nothing: the
* funds stay in the proxy and the flashloan runtime repays both lenders
* after the program.
* - `morphoBlue.repay(mode: 'exact')` repays the proxy's live EURC balance (the
* same EURC `buy.unspentIn` names) straight back into the freshly-minted
* Morpho debt, unwinding the borrow buffer.
* - The payout reads the proxy's USDC balance, splits the USDC leg's reserve
* off it with `core.splitAt`, and transfers the rest to the signer: the
* loan proceeds and the `mode: 'max'` repay's leftover.
*
* After execution the signer holds a Morpho Blue position with
* `collateralAmount` WETH collateral and EURC debt equal to the original Aave
* debt plus only the consumed slippage/fee; the Aave position is closed.
*/
export const buildAaveToMorphoDebtMigrationWithSwapExactOut = ({
owner,
collateralAmount,
debtAmount,
morphoBorrowAmount,
maxSlippageBps = DEFAULT_MAX_SLIPPAGE_BPS,
// The rest is the optional partner-fee fields. Spreading them forwards only
// the fields the caller set, so no fee policy is baked in by default.
...partnerFee
}: AaveToMorphoDebtMigrationWithSwapExactOutInput): {
flow: Flow;
request: ComposeCompileRequest;
} => {
const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
// The USDC the BUY must produce: the flashloan principal plus the leg's
// `maxFee`, the default fee cap (5 bps of the principal, rounded up, since
// Aave rounds its premium half-up). This is the leg's reserve: the proxy
// keeps it through the program and the runtime repays Aave from it. The
// request states the same `maxFee` on the leg, so client and server agree
// on the cap.
const maxFee = flashloanMaxFee({
providerKind: 'aave-v3',
amount: debtAmount,
});
const exactUsdcOut = (BigInt(debtAmount) + maxFee).toString() as `${bigint}`;
const builder = sdk.flow(8453, {
name: 'aave-to-morpho-debt-migration-with-swap-exact-out',
inputs: {
initialCollateral: resources.erc20(BASE_WETH, 8453),
debtFlashloan: resources.erc20(BASE_USDC, 8453),
collateralFlashloan: resources.erc20(BASE_WETH, 8453),
},
});
// --- Phase 1: provision the Aave V3 borrow position ----------------------
// WETH → aBasWETH via the aave routing edge family (Aave V3 supply).
const supplyToAave = builder.lifi.zap('supply-to-aave', {
bind: { amountIn: builder.inputs.initialCollateral },
config: { resourceOut: resources.erc20(A_BAS_WETH, 8453) },
});
// Borrow USDC against the freshly supplied collateral. The `borrowed`
// resource is left unbound: it stays on the proxy as the user's loan
// proceeds, and `payout-borrow-proceeds` forwards it to the signer.
builder.aave.borrow('borrow-from-aave', {
bind: {},
config: {
pool: AAVE_V3_POOL_BASE,
asset: BASE_USDC,
variableDebtToken: VDEBT_BAS_USDC,
amount: debtAmount,
},
});
// --- Phase 2: migrate to Morpho with two concurrent flashloans -----------
// Settle the Aave USDC debt with flashloan #1. mode: 'max' makes Aave's Pool
// clamp paybackAmount to the outstanding debt exactly, so any unspent
// flashloan principal stays on the proxy and reaches the payout below.
builder.aave.repay('repay-aave', {
bind: {
assetIn: builder.inputs.debtFlashloan,
onBehalfOf: builder.context.executionAddress,
},
config: { pool: AAVE_V3_POOL_BASE, mode: 'max' },
});
// Withdraw the freed WETH from Aave (aBasWETH → WETH) via routing.
const withdrawFromAave = builder.lifi.zap('withdraw-from-aave', {
bind: { amountIn: supplyToAave.amountOut },
config: { resourceOut: resources.erc20(BASE_WETH, 8453) },
});
// Open the Morpho Blue position with flashloan #2's WETH.
builder.morphoBlue.supplyCollateral('supply-to-morpho', {
bind: { assetIn: builder.inputs.collateralFlashloan },
config: { marketParams: MORPHO_WETH_EURC_MARKET, mode: 'exact' },
});
// Borrow a capped (generously over-sized) EURC amount at the destination's
// cheaper APR. The over-borrow is intentional and is unwound below.
const morphoBorrow = builder.morphoBlue.borrow('borrow-from-morpho', {
bind: {},
config: {
marketParams: MORPHO_WETH_EURC_MARKET,
amount: morphoBorrowAmount,
},
});
// Exact-output BUY: produce EXACTLY `exactUsdcOut` USDC from the borrowed
// EURC, pulling only the EURC needed and refunding the rest to the proxy
// (surfaced as `unspentIn`). `amountOut` is the USDC leg's whole reserve.
const buyUsdc = builder.paraswap.buy('buy-usdc-exact', {
bind: { amountIn: morphoBorrow.borrowed },
config: {
resourceOut: resources.erc20(BASE_USDC, 8453),
exactAmountOut: exactUsdcOut,
srcDecimals: EURC_DECIMALS,
destDecimals: USDC_DECIMALS,
maxSlippageBps,
...partnerFee,
},
});
// Earmark the exact BUY output for the USDC flashloan leg. One repay node:
// `amountOut` is the leg's whole reserve.
builder.experimental.lifi.flashloanRepay('repay-debt-flashloan', {
bind: { funds: buyUsdc.amountOut },
});
// Earmark the Aave withdrawal for the WETH flashloan leg. Balancer V2
// charges no fee, so the withdrawn principal alone covers the leg.
builder.experimental.lifi.flashloanRepay('repay-collateral-flashloan', {
bind: { funds: withdrawFromAave.amountOut },
});
// Unwind the over-borrow: repay the proxy's FULL residual EURC back into the
// freshly-minted Morpho debt, so the migrated debt equals exactly the EURC the
// swap consumed. The live EURC balance equals `buy.unspentIn`
// (morphoBorrowAmount − sold): Augustus's refund below the cap plus the
// headroom we over-borrowed above it (morphoBorrowAmount − cap), which
// Augustus never pulled. Repaying it leaves zero idle EURC. mode: 'exact'
// pulls precisely this balance; mode: 'max' would repay the FULL Morpho debt
// in shares mode (reading Position.borrowShares) and pull far more EURC than
// the residual, reverting with "transfer amount exceeds balance".
const eurcResidual = builder.core.balanceOf('read-eurc-residual', {
bind: {},
config: { token: BASE_EURC },
});
builder.morphoBlue.repay('repay-morpho-remainder', {
bind: {
assetIn: eurcResidual.balance,
onBehalfOf: builder.context.executionAddress,
},
config: { marketParams: MORPHO_WETH_EURC_MARKET, mode: 'exact' },
});
// Pay out the USDC above the leg's reserve: the loan proceeds and the
// repay's leftover.
payOutUsdcAboveReserve(builder, exactUsdcOut);
const flow = builder.build();
const assumptions: Record<string, bigint> = {
'buy-usdc-exact.amountIn': BigInt(morphoBorrowAmount),
};
const request = sdk.request(flow, {
signer: owner,
inputs: {
// Supply Aave's worst-case rounding skew over the flashloaned
// `collateralAmount`, so the Aave withdrawal (which rounds down by up to
// that skew) still covers the Balancer collateral-flashloan principal at
// settlement. The flashloan, and the migrated Morpho collateral, stay at
// the full `collateralAmount`; the few extra wei stay on the proxy.
initialCollateral: materialisers.directDeposit({
amount: (
BigInt(collateralAmount) + AAVE_SAME_BLOCK_SKEW_WEI
).toString() as `${bigint}`,
}),
debtFlashloan: materialisers.experimental.flashloan({
providerKind: 'aave-v3',
amount: debtAmount,
maxFee,
}),
collateralFlashloan: materialisers.experimental.flashloan({
providerKind: 'balancer-v2',
amount: collateralAmount,
}),
},
assumptions,
});
return { flow, request };
};