@lifi/composer-sdk 0.0.1-alpha

package/src/examples/rawCallWithArithmetic.ts

@@ -0,0 +1,78 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk } from '../index.js';
+import type { Address } from '../types.js';
+
+import { BASE_URL } from './config.js';
+
+// Example contract address for a non-standard oracle
+const ORACLE = '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419';
+
+export interface RawCallWithArithmeticInput {
+  readonly owner: Address;
+}
+
+/**
+ * Query a non-standard contract with pre-encoded calldata, then derive
+ * values from the result using multiply, divideDown, and divideUp.
+ *
+ * Demonstrates:
+ * - core.rawCall to invoke a contract with pre-encoded calldata
+ * - core.multiply to scale a raw value
+ * - core.divideDown / core.divideUp for rounding-aware division
+ */
+export const buildRawCallWithArithmetic = ({
+  owner,
+}: RawCallWithArithmeticInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  const builder = sdk.flow(1, {
+    name: 'raw-call-with-arithmetic',
+    inputs: {},
+  });
+
+  // Call an oracle contract with pre-encoded calldata for latestAnswer().
+  // selector: 0x50d25bcd = keccak256("latestAnswer()")[:4]
+  const oracleResult = builder.core.rawCall('read-oracle', {
+    bind: {},
+    config: {
+      target: ORACLE,
+      calldata: '0x50d25bcd',
+      callType: 'StaticCall',
+      resultType: 'uint256',
+    },
+  });
+
+  // Scale the oracle result by multiplying with itself.
+  // This models squaring a price value for demonstration purposes.
+  const scaled = builder.core.multiply('scale-up', {
+    bind: { a: oracleResult.result, b: oracleResult.result },
+  });
+
+  // Divide down (floor) by a divisor — models conservative conversion.
+  const floorResult = builder.core.divideDown('floor-convert', {
+    bind: { a: scaled.result, b: oracleResult.result },
+  });
+
+  // Divide up (ceil) by the same divisor — models optimistic conversion.
+  const ceilResult = builder.core.divideUp('ceil-convert', {
+    bind: { a: scaled.result, b: oracleResult.result },
+  });
+
+  // Verify the floor result is no greater than the ceil result.
+  builder.core.assertLte('check-floor-lte-ceil', {
+    bind: { a: floorResult.result, b: ceilResult.result },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {},
+  });
+
+  return { flow, request };
+};

package/src/examples/readContractState.ts

@@ -0,0 +1,77 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk } from '../index.js';
+import type { Address } from '../types.js';
+
+import { BASE_URL } from './config.js';
+
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+// Example ERC-4626 vault address (Steakhouse USDC on Ethereum mainnet)
+const VAULT = '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB';
+
+export interface ReadContractStateInput {
+  readonly owner: Address;
+}
+
+/**
+ * Read on-chain state using three different strategies:
+ * peek (compile-time), staticCall (execution-time), and balanceOf (resource).
+ *
+ * Demonstrates:
+ * - core.peek to read a vault's totalAssets at compile time (baked as literal)
+ * - core.staticCall to read totalSupply at execution time (fresh value)
+ * - core.balanceOf to read a token balance as a tracked resource
+ */
+export const buildReadContractState = ({
+  owner,
+}: ReadContractStateInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  const builder = sdk.flow(1, {
+    name: 'read-contract-state',
+    inputs: {},
+  });
+
+  // Read vault totalAssets at compile time.
+  // The result is resolved off-chain and baked into the program as a literal.
+  builder.core.peek('total-assets', {
+    bind: {},
+    config: {
+      target: VAULT,
+      functionSignature: 'function totalAssets() view returns (uint256)',
+    },
+  });
+
+  // Read vault totalSupply at execution time.
+  // Unlike peek, this value is read on-chain during VM execution.
+  builder.core.staticCall('total-supply', {
+    bind: {},
+    config: {
+      target: VAULT,
+      functionSignature: 'function totalSupply() view returns (uint256)',
+    },
+  });
+
+  // Read the owner's USDC balance as a tracked resource.
+  // Produces a resource handle that downstream nodes can consume.
+  builder.core.balanceOf('usdc-balance', {
+    bind: {},
+    config: {
+      token: USDC,
+      owner,
+    },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {},
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/run.ts

@@ -0,0 +1,168 @@
+/**
+ * Example harness — builds a request and sends it to a live compose backend.
+ *
+ * Usage:
+ *   COMPOSER_BASE_URL=https://composer.li.quest yarn example <name>
+ *
+ * Pass LIFI_API_KEY to authenticate:
+ *   LIFI_API_KEY=your-key COMPOSER_BASE_URL=https://composer.li.quest yarn example <name>
+ *
+ * Available examples:
+ *   approve-deposit   — approve vault allowance then deposit USDC
+ *   consolidate       — consolidate ERC-20 balances to USDC
+ *   consolidate-eth   — consolidate ERC-20 balances to native ETH
+ *   deposit-proxy     — deposit tokens already on the proxy into Aave
+ *   dust-sweep        — split USDC 80/20 and sweep leftover dust
+ *   swap              — swap WETH to USDC via LI.FI
+ *   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
+ *   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
+ *   swap-validate     — swap WETH to USDC with output validation bounds
+ *   swap-allow-revert — swap WETH to USDC with allow-revert policy
+ *   raw-call          — query a contract with raw calldata + arithmetic
+ *   read-state        — read on-chain state via peek, staticCall, balanceOf
+ *   redeem            — redeem ERC-4626 vault shares via core.call
+ *   claim             — claim rewards from a contract (resource-free call)
+ *   wrap-eth          — wrap native ETH into WETH via ValueCall
+ *   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
+ */
+import type { ComposeCompileRequest } from '@lifi/compose-spec';
+
+import { createComposeSdk } from '../sdk.js';
+
+import { buildApproveAndDeposit } from './approveAndDeposit.js';
+import {
+  buildClaimRewards,
+  buildRedeemFromVault,
+  buildWrapEth,
+} from './callContract.js';
+import { API_KEY, BASE_URL, OWNER, PROXY, RECIPIENT } from './config.js';
+import { buildConsolidateToEth } from './consolidateToEth.js';
+import { buildConsolidateStablesToUsdc } from './consolidateToUsdc.js';
+import { buildDepositFromProxy } from './depositFromProxy.js';
+import { buildDustSweepExample } from './dustSweep.js';
+import { buildLifiSwapExample } from './lifiSwap.js';
+import { buildLifiZapExample } from './lifiZap.js';
+import { buildRawCallWithArithmetic } from './rawCallWithArithmetic.js';
+import { buildReadContractState } from './readContractState.js';
+import { buildSplitAndZapExample } from './splitAndZap.js';
+import { buildSplitWithArithmetic } from './splitWithArithmetic.js';
+import { buildSwapAndZapExample } from './swapAndZap.js';
+import { buildSwapToRecipient } from './swapToRecipient.js';
+import { buildSwapWithAllowRevertExample } from './swapWithAllowRevert.js';
+import { buildSwapWithBalanceCheck } from './swapWithBalanceCheck.js';
+import { buildSwapWithOutputValidation } from './swapWithOutputValidation.js';
+import { buildPartialTransfer, buildTransferTokens } from './transferTokens.js';
+import { buildUntypedOpWithTypedRef } from './untypedOpWithTypedRef.js';
+
+const EXAMPLES: Record<string, () => ComposeCompileRequest> = {
+  'approve-deposit': () =>
+    buildApproveAndDeposit({ owner: OWNER, amount: '1000000000' }).request,
+  consolidate: () =>
+    buildConsolidateStablesToUsdc({
+      owner: OWNER,
+      usdtAmount: '1000000000',
+      daiAmount: '1000000000000000000000',
+      fraxAmount: '1000000000000000000000',
+      lusdAmount: '1000000000000000000000',
+    }).request,
+  'consolidate-eth': () =>
+    buildConsolidateToEth({
+      owner: OWNER,
+      wethAmount: '1000000000000000000',
+      usdcAmount: '1000000000',
+      usdtAmount: '1000000000',
+      daiAmount: '1000000000000000000000',
+    }).request,
+  'deposit-proxy': () =>
+    buildDepositFromProxy({
+      owner: OWNER,
+      proxyAddress: PROXY,
+      expectedAmount: '1000000000',
+    }).request,
+  'dust-sweep': () => buildDustSweepExample().request,
+  swap: () => buildLifiSwapExample().request,
+  'split-zap': () => buildSplitAndZapExample().request,
+  'split-arithmetic': () =>
+    buildSplitWithArithmetic({ owner: OWNER, amount: '1000000000' }).request,
+  zap: () => buildLifiZapExample().request,
+  'swap-zap': () => buildSwapAndZapExample().request,
+  'swap-check': () =>
+    buildSwapWithBalanceCheck({ owner: OWNER, amount: '1000000000000000000' })
+      .request,
+  'swap-recipient': () =>
+    buildSwapToRecipient({
+      owner: OWNER,
+      recipient: RECIPIENT,
+      wethAmount: '1000000000000000000',
+      daiAmount: '500000000000000000000',
+    }).request,
+  'swap-validate': () =>
+    buildSwapWithOutputValidation({
+      owner: OWNER,
+      amount: '1000000000000000000',
+      expectedOut: '3000000000',
+    }).request,
+  'swap-allow-revert': () => buildSwapWithAllowRevertExample().request,
+  'raw-call': () => buildRawCallWithArithmetic({ owner: OWNER }).request,
+  'read-state': () => buildReadContractState({ owner: OWNER }).request,
+  redeem: () =>
+    buildRedeemFromVault({ owner: OWNER, amount: '1000000000000000000' })
+      .request,
+  claim: () => buildClaimRewards({ owner: OWNER }).request,
+  'wrap-eth': () =>
+    buildWrapEth({ owner: OWNER, amount: '1000000000000000000' }).request,
+  transfer: () =>
+    buildTransferTokens({
+      owner: OWNER,
+      recipient: RECIPIENT,
+      amount: '1000000000',
+    }).request,
+  'partial-transfer': () =>
+    buildPartialTransfer({
+      owner: OWNER,
+      recipient: RECIPIENT,
+      amount: '1000000000',
+    }).request,
+  'untyped-ref': () => buildUntypedOpWithTypedRef({ owner: OWNER }).request,
+};
+
+const run = async () => {
+  const name = process.argv[2];
+  const builder = name ? EXAMPLES[name] : undefined;
+
+  if (!builder) {
+    const valid = Object.keys(EXAMPLES).join(', ');
+    console.error(
+      `Error: ${
+        name ? `unknown example "${name}"` : 'no example specified'
+      }\n` +
+        `Valid examples: ${valid}\n` +
+        `Usage: COMPOSER_BASE_URL=https://composer.li.quest yarn example <name>`,
+    );
+    process.exit(1);
+  }
+  console.log(`Running example: ${name}`);
+
+  const request = builder();
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  console.log('--- Request ---');
+  console.log(JSON.stringify(request, null, 2));
+
+  console.log(`\n--- Compiling against ${BASE_URL} ---`);
+  const result = await sdk.client.compile(request);
+
+  console.log('\n--- Result ---');
+  console.log(JSON.stringify(result, null, 2));
+};
+
+run().catch((err: unknown) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/examples/splitAndZap.ts

@@ -0,0 +1,73 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  createComposeSdk,
+  guards,
+  materialisers,
+  resources,
+} from '../index.js';
+
+import { BASE_URL, OWNER } from './config.js';
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+// Aave v3 aEthUSDC receipt token on Ethereum mainnet
+const A_ETH_USDC = '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c';
+// Steakhouse USDC (Morpho MetaMorpho vault) on Ethereum mainnet
+const STEAKHOUSE_USDC = '0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB';
+
+/**
+ * Split USDC 60/40 and zap each portion into a different vault.
+ *
+ * Demonstrates:
+ * - core.split to divide a resource by basis-point ratio
+ * - Threading split outputs into two independent lifi.zap nodes
+ * - Slippage guards on both zap outputs
+ */
+export const buildSplitAndZapExample = (): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  const builder = sdk.flow(1, {
+    name: 'split-usdc-to-two-vaults',
+    inputs: {
+      amountIn: resources.erc20(USDC, 1),
+    },
+  });
+
+  // Split USDC 60/40 — 6000 bps to `a`, remainder to `b`.
+  const { a, b } = builder.core.split('split', {
+    bind: { source: builder.inputs.amountIn },
+    config: { bps: 6000 },
+  });
+
+  // Zap 60% into Aave v3 aEthUSDC.
+  builder.lifi.zap('zap-aave', {
+    bind: { amountIn: a },
+    config: {
+      resourceOut: resources.erc20(A_ETH_USDC, 1),
+    },
+    guards: [guards.slippage({ port: 'amountOut', bps: 100 })],
+  });
+
+  // Zap 40% into Steakhouse USDC (Morpho).
+  builder.lifi.zap('zap-morpho', {
+    bind: { amountIn: b },
+    config: {
+      resourceOut: resources.erc20(STEAKHOUSE_USDC, 1),
+    },
+    guards: [guards.slippage({ port: 'amountOut', bps: 100 })],
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: OWNER,
+    inputs: {
+      amountIn: materialisers.directDeposit({ amount: '10000000000' }),
+    },
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/splitWithArithmetic.ts

@@ -0,0 +1,93 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, materialisers, resources } from '../index.js';
+import type { Address } from '../types.js';
+
+import { BASE_URL } from './config.js';
+
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+
+export interface SplitWithArithmeticInput {
+  readonly owner: Address;
+  readonly amount: `${bigint}`;
+}
+
+/**
+ * Split USDC 70/30, then verify the parts with arithmetic and assertions.
+ *
+ * Demonstrates:
+ * - core.add to reconstruct the whole from parts
+ * - core.subtract to compute the difference between parts
+ * - core.assertEqual to verify reconstruction matches the original
+ * - core.assertNotEqual to verify the parts are distinct
+ * - core.assertGt / core.assertLt to verify ordering of unequal parts
+ */
+export const buildSplitWithArithmetic = ({
+  owner,
+  amount,
+}: SplitWithArithmeticInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  const builder = sdk.flow(1, {
+    name: 'split-with-arithmetic',
+    inputs: {
+      amountIn: resources.erc20(USDC, 1),
+    },
+  });
+
+  // Split USDC 70/30.
+  const { a: larger, b: smaller } = builder.core.split('split', {
+    bind: { source: builder.inputs.amountIn },
+    config: { bps: 7000 },
+  });
+
+  // Add the two parts back together.
+  const sum = builder.core.add('sum', {
+    bind: { a: larger, b: smaller },
+  });
+
+  // Compute the difference between the larger and smaller portions.
+  const diff = builder.core.subtract('diff', {
+    bind: { a: larger, b: smaller },
+  });
+
+  // The sum of parts should equal the original input.
+  builder.core.assertEqual('check-sum-equals-input', {
+    bind: { a: sum.result, b: builder.inputs.amountIn },
+  });
+
+  // The two parts should not be equal (70/30 split).
+  builder.core.assertNotEqual('check-parts-differ', {
+    bind: { a: larger, b: smaller },
+  });
+
+  // The 70% portion should be strictly greater than the 30% portion.
+  builder.core.assertGt('check-larger-gt-smaller', {
+    bind: { a: larger, b: smaller },
+  });
+
+  // The 30% portion should be strictly less than the 70% portion.
+  builder.core.assertLt('check-smaller-lt-larger', {
+    bind: { a: smaller, b: larger },
+  });
+
+  // The difference should be greater than zero (non-trivial gap).
+  builder.core.assertGt('check-diff-positive', {
+    bind: { a: diff.result, b: smaller },
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      amountIn: materialisers.directDeposit({ amount }),
+    },
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/swapAndZap.ts

@@ -0,0 +1,72 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import {
+  createComposeSdk,
+  guards,
+  materialisers,
+  resources,
+} from '../index.js';
+
+import { BASE_URL, OWNER } from './config.js';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+// Aave aEthUSDC receipt token on Ethereum mainnet
+const A_ETH_USDC = '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c';
+
+/**
+ * Swap WETH to USDC, then zap the USDC into an Aave lending position via LI.FI.
+ *
+ * Demonstrates:
+ * - Chaining a swap into a zap by threading output handles
+ * - The swap's amountOut feeds directly into the zap's amountIn
+ * - Slippage guard on the zap output (swap output has providesMinimum)
+ */
+export const buildSwapAndZapExample = (): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  // Declare the flow with a single WETH input on Ethereum mainnet.
+  const builder = sdk.flow(1, {
+    name: 'swap-and-zap-weth-to-aave',
+    inputs: {
+      amountIn: resources.erc20(WETH, 1),
+    },
+  });
+
+  // Swap WETH → USDC via LI.FI.
+  const swapOutputs = builder.lifi.swap('swap', {
+    bind: { amountIn: builder.inputs.amountIn },
+    config: {
+      resourceOut: resources.erc20(USDC, 1),
+      slippage: 0.03,
+    },
+  });
+
+  // Zap the swapped USDC into Aave's aEthUSDC position via LI.FI.
+  // The swap's amountOut handle is threaded directly into the zap's amountIn.
+  builder.lifi.zap('zap', {
+    bind: { amountIn: swapOutputs.amountOut },
+    config: {
+      resourceOut: resources.erc20(A_ETH_USDC, 1),
+    },
+    guards: [guards.slippage({ port: 'amountOut', bps: 100 })],
+  });
+
+  const flow = builder.build();
+
+  // Build the compile request.
+  // directDeposit transfers a fixed amount of WETH into the VM.
+  const request = sdk.request(flow, {
+    signer: OWNER,
+    inputs: {
+      amountIn: materialisers.directDeposit({
+        amount: '1000000000000000000',
+      }),
+    },
+    sweepTo: builder.context.sender,
+  });
+
+  return { flow, request };
+};

package/src/examples/swapToRecipient.ts

@@ -0,0 +1,109 @@
+import type { ComposeCompileRequest, Flow } from '@lifi/compose-spec';
+
+import { createComposeSdk, materialisers, resources } from '../index.js';
+import type { Address } from '../types.js';
+
+import { BASE_URL } from './config.js';
+
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const DAI = '0x6B175474E89094C44Da98b954EedeAC495271d0F';
+
+export interface SwapToRecipientInput {
+  readonly owner: Address;
+  readonly recipient: Address;
+  readonly wethAmount: `${bigint}`;
+  readonly daiAmount: `${bigint}`;
+}
+
+/**
+<<<<<<< HEAD
+<<<<<<< HEAD
+ * Swap WETH and DAI into USDC, merge the outputs, transfer to a recipient,
+=======
+ * Swap WETH and DAI into USDC, merge the outputs, transfer to the recipient,
+>>>>>>> a2c178fd (chore: fix examples)
+ * and verify the recipient holds the combined balance.
+=======
+ * Swap WETH and DAI into USDC, merge the outputs, and deliver to a recipient.
+>>>>>>> 4c49ff9b (fix: support resource bindings for handle ports)
+ *
+ * Demonstrates:
+ * - Multiple resource inputs (two ERC-20 tokens)
+ * - A handle input (recipient address as a scalar value)
+ * - Chaining two swaps through a merge node
+<<<<<<< HEAD
+<<<<<<< HEAD
+ * - Explicit core.transfer to send merged tokens to the recipient
+ * - Copy-mode resource input on invariant.balanceAtLeast (reads without consuming)
+=======
+ * - core.transfer to send merged tokens to the recipient
+ * - Using invariant.balanceAtLeast with a handle input for the account
+>>>>>>> a2c178fd (chore: fix examples)
+=======
+ * - Using `sweepTo` with a handle input to deliver tokens to the recipient
+>>>>>>> 4c49ff9b (fix: support resource bindings for handle ports)
+ * - Typed request inputs inferred from the flow schema
+ */
+export const buildSwapToRecipient = ({
+  owner,
+  recipient,
+  wethAmount,
+  daiAmount,
+}: SwapToRecipientInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL });
+
+  // Declare the flow on Ethereum mainnet with two token inputs and one address input.
+  const builder = sdk.flow(1, {
+    name: 'swap-to-recipient',
+    inputs: {
+      wethIn: resources.erc20(WETH, 1),
+      daiIn: resources.erc20(DAI, 1),
+      recipient: 'address',
+    },
+  });
+
+  // Swap WETH → USDC via LI.FI.
+  const wethSwap = builder.lifi.swap('swap-weth', {
+    bind: { amountIn: builder.inputs.wethIn },
+    config: {
+      resourceOut: resources.erc20(USDC, 1),
+      slippage: 0.03,
+    },
+  });
+
+  // Swap DAI → USDC via LI.FI.
+  const daiSwap = builder.lifi.swap('swap-dai', {
+    bind: { amountIn: builder.inputs.daiIn },
+    config: {
+      resourceOut: resources.erc20(USDC, 1),
+      slippage: 0.03,
+    },
+  });
+
+  // Merge the two USDC outputs into a single resource.
+  builder.core.merge('merge-usdc', {
+    bind: { a: wethSwap.amountOut, b: daiSwap.amountOut },
+  });
+
+  const flow = builder.build();
+
+  // Build the compile request with typed inputs matching the flow schema.
+  // Resource inputs use directDeposit materialisers with fixed amounts.
+  // The handle input passes the recipient address as a plain string.
+  // sweepTo delivers all terminal resources (the merged USDC) to the recipient.
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      wethIn: materialisers.directDeposit({ amount: wethAmount }),
+      daiIn: materialisers.directDeposit({ amount: daiAmount }),
+      recipient,
+    },
+    sweepTo: recipient,
+  });
+
+  return { flow, request };
+};