@lifi/composer-sdk 0.4.0 → 0.5.0

package/src/examples/flySwap.ts

@@ -0,0 +1,167 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, materialisers, resources } from '../index.js';
+
+import { API_KEY, BASE_URL, OWNER } from './config.js';
+
+// Base mainnet. Pendle PT-USDC, its underlying USDC, and WETH.
+const BASE = 8453;
+const PT_USDC = '0x0d18b7bab00988a442e31065e76286844809dc9a';
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+const WETH = '0x4200000000000000000000000000000000000006';
+
+/**
+ * Exit a Pendle PT position and swap **all** of the proceeds to WETH on Base.
+ *
+ * ## The problem this solves
+ *
+ * Every other swap op bakes a fixed input amount into the router calldata at
+ * quote time. That is fine when you know the amount up front, and useless when
+ * you do not: a PT exit routes through an on-chain AMM quote, so it can deliver
+ * a little more or a little less than the estimate. With `lifi.swap` you must
+ * name an amount, and whatever the exit over-delivers is stranded in the proxy
+ * (or, if it under-delivers, the flow reverts).
+ *
+ * `fly.swap` is the only swap that can sit downstream of a producer whose output
+ * is not known until execution. Fly's `DexAggregator` supports a variable-input
+ * mode — the `amountIn` word is excluded from the signed quote, so leaving it
+ * unset makes the contract resolve the amount on-chain: for an erc20 input,
+ * `min(our balance, the allowance we granted)`; for a native input, whatever
+ * `msg.value` the op forwards. The op therefore swaps *all* of whatever
+ * actually arrives. Either leg may be the chain's gas coin.
+ *
+ * ## The two numbers, which are independent
+ *
+ * This is the thing to get right, because they sound alike and are not:
+ *
+ * - **`inputVarianceBps`** describes the **upstream**: how far its real output
+ *   may sit either side of the estimate, symmetrically. It is a quantity, not a
+ *   price.
+ * - **`maxSlippageBps`** is ordinary **price** protection: expected rate versus
+ *   achieved rate, sized on the pair, and completely unaffected by how much
+ *   input turns up. It is enforced on-chain as a *rate* against the input
+ *   actually consumed, so the percentage protection is identical at any size.
+ *
+ * Neither is derived from the other and neither constrains the other. A
+ * `maxSlippageBps` below `inputVarianceBps` is perfectly legitimate.
+ *
+ * ## Choosing `inputVarianceBps` (default 50 = 0.5%)
+ *
+ * The compile-time input amount is **simulated** at the current block, not
+ * guessed — the compiler runs the upstream and reads what it produced. So this
+ * field covers only simulate-to-execute drift: block delay, yield accrued in
+ * that window, and third parties moving the upstream's rate in between. Tens of
+ * basis points, not percent.
+ *
+ * Widening it is safe but not free. The bottom of the band is what the compose
+ * response publishes as `amountOutMin`, so a wider band advertises a weaker
+ * minimum to whoever consumes your quote.
+ *
+ * ## Ignore the 50% slippage in the Fly calldata
+ *
+ * If you inspect the compiled transaction you will see a 50% slippage figure
+ * where you configured 1%. That is deliberate and it is not your setting. All
+ * Fly's own `slippage` parameter does is price its `amountOutMin`, which is an
+ * absolute amount fixed at quote time and therefore cannot scale down when a
+ * legitimately smaller input arrives. The op sends a high value so that floor
+ * can never be the binding constraint, and enforces its own rate-based bound
+ * instead — which is strictly tighter for every in-band delivery. The number
+ * that protects you is `maxSlippageBps`.
+ *
+ * ## What happens outside the band
+ *
+ * With `E` the simulated exit output, `v = inputVarianceBps`:
+ *
+ *     E = 1000, v = 200 (2%), p = 100 (1%)  ->  band [980, 1020]
+ *
+ *     delivered 1020  -> consumes 1020, nothing left over   (band top)
+ *     delivered 1000  -> consumes 1000, nothing left over
+ *     delivered  980  -> consumes  980, nothing left over   (band bottom)
+ *     delivered  950  -> reverts on the op's own floor invariant
+ *     delivered 1200  -> consumes 1020; the 180 excess is swept back to you
+ *
+ * Both out-of-band outcomes are safe. The upward cap exists because Fly
+ * confiscates output above the quoted expectation rather than rejecting it, so
+ * the op never approves more than it quoted for. Note the excess only comes back
+ * if the run supplies `sweepTo` — without it the residue sits in the proxy until
+ * a later flow or an explicit `POST /compose/sweep` collects it.
+ *
+ * ## Two limitations worth knowing before you author
+ *
+ * 1. **`fly.swap` cannot sit downstream of another *prepared* op.** `lifi.zap`
+ *    (used here) and other plain ops are fine. `lifi.swap` and `paraswap.buy`
+ *    are prepared, and the compiler rejects those chains with a message about
+ *    splitting the flow across a continuation.
+ * 2. **The upstream must deliver to the proxy.** `lifi.zap` does so by
+ *    construction. An upstream that exposes its own delivery address — such as
+ *    `morphoBlue.withdraw`'s `receiver` — must have it bound to
+ *    `context.executionAddress`, or the amount it reports will diverge from what
+ *    the proxy actually holds and the op's custody assertion reverts.
+ *
+ * Demonstrates:
+ * - A variable-input swap consuming an upstream's entire, runtime-determined output
+ * - `lifi.zap` as the nondeterministic producer (a PT exit through an AMM quote)
+ * - `sweepTo`, which is what returns any out-of-band residue to the sender
+ *
+ * `fly.swap` is always registered on the backend; without `FLY_API_KEY` it uses
+ * Fly's public host.
+ *
+ * See `docs/references/fly-api.md` for the router behaviour all of this rests on.
+ */
+export const buildFlySwapExample = (): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(BASE, {
+    name: 'pt-usdc-exit-swap-all-to-weth',
+    inputs: {
+      amountIn: resources.erc20(PT_USDC, BASE),
+    },
+  });
+
+  // Exit the PT position to its underlying USDC. `lifi.zap` declares no
+  // output-amount estimator, so the compiler cannot resolve the next node's
+  // input statically and instead simulates this node to read what it really
+  // produced. That simulated value is what `fly.swap` quotes against, and it is
+  // why a 50 bps band is enough.
+  const exitPt = builder.lifi.zap('exitPt', {
+    bind: { amountIn: builder.inputs.amountIn },
+    config: {
+      resourceOut: resources.erc20(USDC, BASE),
+    },
+  });
+
+  // Swap the entire exit output to WETH.
+  //
+  // No slippage guard here, and none is accepted: `amountOut` declares
+  // `providesMinimum`, so the op owns its own bound. Attaching one is a
+  // `guard_error`. The published `amountOutMin` is the op's, derived from the
+  // bottom of the input band.
+  builder.fly.swap('swapAllToWeth', {
+    bind: { amountIn: exitPt.amountOut },
+    config: {
+      resourceOut: resources.erc20(WETH, BASE),
+      // The exit is a same-block simulation, so only drift needs covering.
+      inputVarianceBps: 50,
+      // Price protection on the USDC/WETH pair, independent of the above.
+      maxSlippageBps: 100,
+    },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: OWNER,
+    inputs: {
+      // 1 PT-USDC (6 decimals).
+      amountIn: materialisers.directDeposit({ amount: '1000000' }),
+    },
+    // Load-bearing, not boilerplate: this is what returns the unconsumed input
+    // to the sender if the exit over-delivers past the top of the band.
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/lifiZap.ts

@@ -53,6 +53,10 @@ export const buildLifiZapExample = (): {
     inputs: {
       amountIn: materialisers.directDeposit({ amount: '1000000000' }),
     },
+    // This zap's edge keeps `amountOut` inside the execution VM, so sweeping
+    // leftovers back to the sender is safe. Omit `sweepTo` for an edge that
+    // delivers externally (`recipient: 'required'` in discovery): the output
+    // never enters the VM, so a sweep would find nothing to move.
     sweepTo: builder.context.sender,
   });
 

package/src/examples/lifiZapAsync.ts

@@ -0,0 +1,88 @@
+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';
+
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+// Aave aEthUSDC receipt token on Ethereum mainnet
+const A_ETH_USDC = '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c';
+
+export interface LifiZapAsyncInput {
+  readonly owner: Address;
+  readonly recipient: Address;
+}
+
+/**
+ * Zap USDC into a DeFi position whose output settles asynchronously via LI.FI.
+ *
+ * Demonstrates:
+ * - `lifi.zapAsync`, the future-availability sibling of `lifi.zap`
+ * - Binding the required `recipient` input (the async op has no optional
+ *   recipient — the decl is non-optional, so `bind.recipient` is mandatory)
+ * - Omitting `sweepTo`: `availability: 'future'` governs custody, so the
+ *   output is delivered externally and never enters the execution VM — a
+ *   sweep would find nothing to move (custody, not amount reporting)
+ * - Amount reporting is unaffected by availability: when the async lowering
+ *   binds a terminal handle the output still reports `simulated.amountOut`,
+ *   the protocol's in-transaction expected value (an estimate; the delivered
+ *   amount arrives after settlement). `simulated.amountOutMin` appears only
+ *   when a minimum source exists — for a future output that means a floor the
+ *   edge lowering itself reported, never a user guard
+ * - No output guards: the reported value is the initiating-transaction
+ *   estimate, not the asynchronously delivered amount a guard could enforce,
+ *   so `amountOut` is excluded from the generated `TypedGuard` union
+ *   (`guards` typechecks as `TypedGuard<never>[]`) and the compiler rejects
+ *   any guard on it
+ */
+export const buildLifiZapAsyncExample = ({
+  owner,
+  recipient,
+}: LifiZapAsyncInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  // Declare the flow with a single USDC input and the recipient address input.
+  const builder = sdk.flow(1, {
+    name: 'zap-async-usdc-to-aave',
+    inputs: {
+      amountIn: resources.erc20(USDC, 1),
+      recipient: 'address',
+    },
+  });
+
+  // Zap USDC into an async Aave position via LI.FI.
+  // The future output is delivered to `recipient` once the initiating
+  // transaction settles; the recipient binding is required by the op.
+  builder.lifi.zapAsync('zap', {
+    bind: {
+      amountIn: builder.inputs.amountIn,
+      recipient: builder.inputs.recipient,
+    },
+    config: {
+      resourceOut: resources.erc20(A_ETH_USDC, 1),
+    },
+  });
+
+  const flow = builder.build();
+
+  // Build the compile request.
+  // directDeposit transfers a fixed amount of USDC into the VM; the recipient
+  // handle passes the delivery address as a plain string.
+  // No `sweepTo`: the async output is delivered externally to the recipient,
+  // never landing in the VM for a sweep to reach.
+  // NOTE: no production edge sets `availability: 'future'` yet, so this request
+  // resolves to a typed no_route today; it documents the intended shape.
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      amountIn: materialisers.directDeposit({ amount: '1000000000' }),
+      recipient,
+    },
+  });
+
+  return { flow, request };
+};

package/src/examples/routeTokenPair.ts

@@ -0,0 +1,58 @@
+import type { ComposeRouteRequest } from '@lifi/compose-spec';
+
+import { routeAmount } from '../index.js';
+
+import { OWNER } from './config.js';
+
+const NATIVE_ETH = '0x0000000000000000000000000000000000000000';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+
+/**
+ * Wrap 0.1 native ETH into WETH on Ethereum mainnet through
+ * `POST /compose/route`.
+ *
+ * Demonstrates:
+ * - The convenience path: a from/to token pair instead of an authored flow.
+ *   The pair resolves to the catalog's `wrap` edge, and the server authors the
+ *   zap step for it
+ * - `routeAmount.exact` for a fixed input amount (`bigint`, serialised on send)
+ * - The native sentinel address as `fromToken`
+ *
+ * Pure: returns a plain {@link ComposeRouteRequest}, performs no network I/O.
+ * Pass it to `sdk.route(...)` / `sdk.client.route(...)` to compile it.
+ */
+export const buildRouteExactExample = (): ComposeRouteRequest => ({
+  chainId: 1,
+  fromToken: NATIVE_ETH,
+  toToken: WETH,
+  amount: routeAmount.exact(100_000_000_000_000_000n), // 0.1 ETH
+  signer: OWNER,
+  slippageBps: 100,
+});
+
+/**
+ * Unwrap the signer's entire WETH balance back into native ETH on Ethereum
+ * mainnet — the catalog's `unwrap` edge.
+ *
+ * Demonstrates:
+ * - `routeAmount.all` for a balance resolved on-chain at execution time, where
+ *   the passed value is only the quoting stand-in
+ * - `sweepTo` naming the address that receives the output
+ * - `checkOnChainAllowances` so already-sufficient approvals are omitted from
+ *   the response
+ *
+ * Pure: returns a plain {@link ComposeRouteRequest}, performs no network I/O.
+ */
+export const buildRouteAllExample = (): ComposeRouteRequest => ({
+  chainId: 1,
+  fromToken: WETH,
+  toToken: NATIVE_ETH,
+  // Estimate of the balance on hand — the quote and the derived preconditions
+  // are computed against this, but the amount actually moved is the real
+  // balance at execution time.
+  amount: routeAmount.all(10n ** 18n), // ~1 WETH
+  signer: OWNER,
+  sweepTo: OWNER,
+  slippageBps: 50,
+  checkOnChainAllowances: true,
+});

package/src/examples/run.ts

@@ -20,6 +20,8 @@
  *   split-zap         — split USDC 60/40 and zap into Aave + Morpho vaults
  *   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)
+ *   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
  *   swap-recipient    — swap WETH + DAI to USDC and send to recipient
@@ -32,10 +34,16 @@
  *   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
+ *   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
  */
-import type { ComposeCompileRequest } from '@lifi/compose-spec';
+import type {
+  ComposeCompileRequest,
+  ComposeRouteRequest,
+} from '@lifi/compose-spec';
 
-import { createComposeSdk } from '../sdk.js';
+import { type ComposeSdk, createComposeSdk } from '../sdk.js';
 
 import { buildAaveRepay } from './aaveRepay.js';
 import { buildAaveRepayWithATokens } from './aaveRepayWithATokens.js';
@@ -47,12 +55,19 @@ import { buildConsolidateToEth } from './consolidateToEth.js';
 import { buildConsolidateStablesToUsdc } from './consolidateToUsdc.js';
 import { buildDepositFromProxy } from './depositFromProxy.js';
 import { buildDustSweepExample } from './dustSweep.js';
+import { buildFlySwapExample } from './flySwap.js';
 import { buildLifiSwapExample } from './lifiSwap.js';
 import { buildLifiZapExample } from './lifiZap.js';
+import { buildLifiZapAsyncExample } from './lifiZapAsync.js';
 import { buildRawCallWithArithmetic } from './rawCallWithArithmetic.js';
 import { buildReadContractState } from './readContractState.js';
+import {
+  buildRouteAllExample,
+  buildRouteExactExample,
+} from './routeTokenPair.js';
 import { buildSplitAndZapExample } from './splitAndZap.js';
 import { buildSplitWithArithmetic } from './splitWithArithmetic.js';
+import { runSupportedChainsExample } from './supportedChains.js';
 import { buildSwapAndZapExample } from './swapAndZap.js';
 import { buildSwapToRecipient } from './swapToRecipient.js';
 import { buildSwapWithAllowRevertExample } from './swapWithAllowRevert.js';
@@ -106,6 +121,9 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
   'split-arithmetic': () =>
     buildSplitWithArithmetic({ owner: OWNER, amount: '1000000000' }).request,
   zap: () => buildLifiZapExample().request,
+  'zap-async': () =>
+    buildLifiZapAsyncExample({ owner: OWNER, recipient: RECIPIENT }).request,
+  'fly-swap': () => buildFlySwapExample().request,
   'swap-zap': () => buildSwapAndZapExample().request,
   'swap-check': () =>
     buildSwapWithBalanceCheck({ owner: OWNER, amount: '1000000000000000000' })
@@ -146,6 +164,19 @@ const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
   'untyped-ref': () => buildUntypedOpWithTypedRef({ owner: OWNER }).request,
 };
 
+// `/compose/route` examples build a `ComposeRouteRequest` and go to
+// `sdk.route`, not `sdk.client.compile`, so they live in their own registry.
+const ROUTE_EXAMPLES: Record<string, () => ComposeRouteRequest> = {
+  'route-exact': buildRouteExactExample,
+  'route-all': buildRouteAllExample,
+};
+
+// Query examples read from the API instead of building a request to compile,
+// so they take the sdk and print their own output.
+const QUERY_EXAMPLES: Record<string, (sdk: ComposeSdk) => Promise<void>> = {
+  'supported-chains': runSupportedChainsExample,
+};
+
 const run = async () => {
   const args = process.argv.slice(2);
   const useStaged = args.includes('--staged');
@@ -166,10 +197,18 @@ const run = async () => {
     examples = { ...EXAMPLES, ...stagedModule.STAGED_EXAMPLES };
   }
 
+  const queryExample = name ? QUERY_EXAMPLES[name] : undefined;
+  const routeBuilder = name ? ROUTE_EXAMPLES[name] : undefined;
   const builder = name ? examples[name] : undefined;
 
-  if (!builder) {
-    const valid = Object.keys(examples).join(', ');
+  if (!builder && !routeBuilder && !queryExample) {
+    const valid = [
+      ...Object.keys(examples),
+      ...Object.keys(ROUTE_EXAMPLES),
+      ...Object.keys(QUERY_EXAMPLES),
+    ]
+      .sort()
+      .join(', ');
     console.error(
       `Error: ${
         name ? `unknown example "${name}"` : 'no example specified'
@@ -181,9 +220,18 @@ const run = async () => {
   }
   console.log(`Running example: ${name}`);
 
-  const request = builder();
   const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
 
+  // Query examples do their own I/O and printing - there is no request to
+  // show and nothing to compile.
+  if (queryExample) {
+    console.log(`\n--- Querying ${BASE_URL} ---`);
+    await queryExample(sdk);
+    return;
+  }
+
+  const request = routeBuilder ? routeBuilder() : builder!();
+
   console.log('--- Request ---');
   console.log(
     JSON.stringify(
@@ -195,7 +243,9 @@ const run = async () => {
   );
 
   console.log(`\n--- Compiling against ${BASE_URL} ---`);
-  const result = await sdk.client.compile(request);
+  const result = routeBuilder
+    ? await sdk.route(request as ComposeRouteRequest)
+    : await sdk.client.compile(request as ComposeCompileRequest);
 
   console.log('\n--- Result ---');
   console.log(JSON.stringify(result, null, 2));

package/src/examples/supportedChains.ts

@@ -0,0 +1,122 @@
+import type { ChainSummary } from '../discovery.js';
+import type { ComposeSdk } from '../sdk.js';
+
+/**
+ * The slice of {@link ComposeSdk} these helpers need. Depending on the one
+ * capability rather than the whole SDK keeps them testable with a two-line
+ * fake, and documents that nothing here touches the compile path.
+ */
+export type SupportedChainsSource = Pick<ComposeSdk, 'getSupportedChains'>;
+
+/**
+ * A memoised view of the supported-chain list.
+ */
+export interface SupportedChainsCache {
+  /** Supported chains, ascending by `chainId`. Fetched once, then served from memory. */
+  readonly get: () => Promise<readonly ChainSummary[]>;
+  /**
+   * Resolves when `chainId` is supported, rejects with an actionable message
+   * naming the alternatives when it is not.
+   */
+  readonly assertSupported: (chainId: number) => Promise<void>;
+  /**
+   * Display label for `chainId`, or `undefined` when the deployment does not
+   * support it. Served from the same cached fetch as {@link get}.
+   */
+  readonly nameOf: (chainId: number) => Promise<string | undefined>;
+  /** Drops the memoised list so the next {@link get} refetches. */
+  readonly refresh: () => void;
+}
+
+/**
+ * Wraps `sdk.getSupportedChains()` in a cache so a long-lived process pays for
+ * one round trip instead of one per check.
+ *
+ * The SDK deliberately does not cache the list — the backend's chain registry
+ * refreshes periodically, so the right lifetime is the caller's to choose.
+ * Chains are added rarely, so caching for the life of a request handler (or
+ * refreshing on a timer via {@link SupportedChainsCache.refresh}) is usually
+ * right.
+ *
+ * Demonstrates:
+ * - `sdk.getSupportedChains()`, the convenience accessor over `GET /chains`
+ * - Preflighting a chain so an unsupported one fails locally with a message
+ *   naming the alternatives, instead of costing a server round trip
+ * - Turning the per-chain `name` into display labels without a second lookup
+ *   or a hardcoded chain-name table
+ * - Memoising the in-flight promise, not just the settled value, so concurrent
+ *   first callers share one request
+ */
+export const createSupportedChainsCache = (
+  sdk: SupportedChainsSource,
+): SupportedChainsCache => {
+  let inFlight: Promise<readonly ChainSummary[]> | undefined;
+
+  const get = (): Promise<readonly ChainSummary[]> => {
+    // A rejected fetch must not be memoised, or one transient network blip
+    // would poison every later lookup.
+    inFlight ??= sdk.getSupportedChains().catch((err: unknown) => {
+      inFlight = undefined;
+      throw err;
+    });
+    return inFlight;
+  };
+
+  const find = async (chainId: number): Promise<ChainSummary | undefined> =>
+    (await get()).find((chain) => chain.chainId === chainId);
+
+  return {
+    get,
+    assertSupported: async (chainId: number): Promise<void> => {
+      if (await find(chainId)) return;
+      const chains = await get();
+      throw new Error(
+        `Chain ${chainId} is not supported by this Compose deployment. ` +
+          `Supported chains: ${chains
+            .map((chain) => `${chain.name} (${chain.chainId})`)
+            .join(', ')}`,
+      );
+    },
+    nameOf: async (chainId: number): Promise<string | undefined> =>
+      (await find(chainId))?.name,
+    refresh: (): void => {
+      inFlight = undefined;
+    },
+  };
+};
+
+/** Ethereum mainnet — supported by every deployment. */
+const MAINNET = 1;
+/** Not an EVM chain ID any deployment serves; stands in for a bad input. */
+const UNSUPPORTED = 999_999;
+
+/**
+ * Harness entry point: prints the live chain list with names, then shows the
+ * guard accepting a supported chain and rejecting an unsupported one.
+ */
+export const runSupportedChainsExample = async (
+  sdk: SupportedChainsSource,
+): Promise<void> => {
+  const chains = createSupportedChainsCache(sdk);
+
+  const supported = await chains.get();
+  console.log(`Supported chains (${supported.length}):`);
+  for (const { chainId, name } of supported) {
+    console.log(`  ${chainId}\t${name}`);
+  }
+
+  await chains.assertSupported(MAINNET);
+  // Served from cache: no second round trip.
+  console.log(
+    `\n${await chains.nameOf(MAINNET)} (${MAINNET}) is supported — safe to build a request.`,
+  );
+
+  await chains
+    .assertSupported(UNSUPPORTED)
+    .then(() => {
+      throw new Error(`expected chain ${UNSUPPORTED} to be rejected`);
+    })
+    .catch((err: unknown) => {
+      console.log(`\nGuard rejected as expected: ${(err as Error).message}`);
+    });
+};

package/src/generated/config.generated.ts

@@ -203,9 +203,14 @@ export interface CoreCallConfig {
           )[]
       )[]
   )[];
-  approvals?: {
-    spender: Address;
-  }[];
+  approvals?: (
+    | {
+        spender: Address;
+      }
+    | {
+        from: 'sender';
+      }
+  )[];
 }
 
 export interface CoreStaticCallConfig {
@@ -684,6 +689,19 @@ export interface LifiZapConfig {
       };
 }
 
+export interface LifiZapAsyncConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        token: Address;
+        chainId: Positive;
+      };
+}
+
 export interface ParaswapBuyConfig {
   resourceOut:
     | {
@@ -713,6 +731,30 @@ export interface CorePeekConfig {
   args?: string[];
 }
 
+/**
+ * a number between 0 and 3318
+ */
+export type Between03318 = number;
+/**
+ * a number between 0 and 5000
+ */
+export type Between05000 = number;
+
+export interface FlySwapConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        token: Address;
+        chainId: Positive;
+      };
+  inputVarianceBps?: Between03318;
+  maxSlippageBps?: Between05000;
+}
+
 export interface SlippageGuardConfig {
   port: string;
   bps: Between010000;