UNPKG

@lifi/composer-sdk

Version:

Public Composer SDK for building and submitting flows

114 lines (103 loc) • 4.39 kB
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'; const BASE = 8453; const USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'; const WETH = '0x4200000000000000000000000000000000000006'; // Aave V3 aToken for WETH on Base. const A_BAS_WETH = '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7'; const VALIDITY_WINDOW_MS = 3_600_000; export interface ContinuationSettleInput { readonly owner: Address; // Receives the aBasWETH position; defaults to `owner`. readonly recipient?: Address; } /** * Swap USDC to WETH on Base, then escrow the WETH for a deferred settlement * whose leg supplies it to Aave and delivers the aBasWETH position to the * recipient. * * Demonstrates: * - `continuation.settle` funded by an upstream output (`swap.amountOut`) * - The leg (`continuationFlow`) as an ordinary flow built with `sdk.flow` * and assigned with `leg.build()`: here one `lifi.zap` that supplies the * escrowed WETH to Aave * - An outcome in the token the leg produces (aBasWETH): the zap's slippage * guard proves the floor, so `minAmount` is omitted * - `refund` naming the address that receives the escrow balance on expiry * and the leg's residual (optional; defaults to the signer) * * The leg contract: * - Exactly one input: a resource input in the funding token on the escrow * chain. The solver binds the escrow balance to it. * - Produce each outcome into the leg's own proxy and end there. A zap or a * deposit mints into the proxy by default; a node that needs a receiver * binds `leg.context.executionAddress`. A funding input no node consumes * stays in the proxy as the terminal `input.<name>`. Never * pay a recipient: not `destination`, not the provider's settlement * recipient, and never `context.sender` (inside the leg that is the * settlement account, not the user). Never set the leg's own epilogue. At * commit the composer appends the settlement epilogue, which forwards each * outcome to the provider's recipient and the residual to `refund`. * - Omit `funding` when the settle input is a bridge's * `amountOut` (see `continuationBridgeSettle.ts`). * - `minAmount` is optional: a guard or an op floor on the outcome token * proves it, and an unconsumed funding input proves the full funding floor. */ export const buildContinuationSettleExample = ({ owner, recipient = owner, }: ContinuationSettleInput): { flow: Flow; request: ComposeCompileRequest; } => { const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY }); // The leg: runs from the escrow on Base once the WETH has landed there. The // zap supplies the WETH to Aave; the aBasWETH it mints lands in the leg's // proxy, where the settlement epilogue picks it up. The slippage guard on // `amountOut` is the enforced floor the compiler commits. const leg = sdk.flow(BASE, { name: 'settle-leg', inputs: { funding: resources.erc20(WETH, BASE) }, }); leg.lifi.zap('supply', { bind: { amountIn: leg.inputs.funding }, config: { resourceOut: resources.erc20(A_BAS_WETH, BASE) }, guards: [guards.slippage({ port: 'amountOut', bps: 50 })], }); // The main flow: swap USDC to WETH, then escrow the WETH for the leg. const builder = sdk.flow(BASE, { name: 'swap-and-settle', inputs: { amountIn: resources.erc20(USDC, BASE) }, }); const swap = builder.lifi.swap('swap', { bind: { amountIn: builder.inputs.amountIn }, config: { resourceOut: resources.erc20(WETH, BASE) }, }); builder.continuation.settle('settle', { bind: { input: swap.amountOut }, config: { outcomes: [{ token: A_BAS_WETH, destination: recipient, chainId: BASE }], validity: { expiresAtMs: Date.now() + VALIDITY_WINDOW_MS }, provider: 'intent-factory', refund: owner, continuationFlow: leg.build(), }, }); const flow = builder.build(); // No `sweepTo`: the swap output funds the escrow and the outcome is // delivered by the settlement, never landing in the VM. const request = sdk.request(flow, { signer: owner, inputs: { amountIn: materialisers.directDeposit({ amount: '1000000000' }), }, }); return { flow, request }; };