@lifi/composer-sdk 0.7.1 → 0.9.0

package/src/examples/uniswapV3Mint.ts

@@ -0,0 +1,95 @@
+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';
+
+// Uniswap V3 USDC/WETH 0.05% pool on Ethereum mainnet (chainId 1).
+const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+const POSITION_MANAGER = '0xC36442b4a4522E871399CD717aBDD847Ab11FE88';
+const FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+const USDC_WETH_500_POOL = '0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640';
+// Full range: the widest ticks that are multiples of the pool's tick spacing (10).
+const TICK_LOWER = -887270;
+const TICK_UPPER = 887270;
+
+export interface UniswapV3MintInput {
+  readonly owner: Address;
+  readonly usdcAmount: `${bigint}`;
+  readonly wethAmount: `${bigint}`;
+}
+
+/**
+ * Open a full-range Uniswap V3 USDC/WETH position on Ethereum mainnet.
+ *
+ * - `uniswapV3.mint` deposits the proxy's USDC and WETH and mints the
+ *   position NFT straight to the signer.
+ * - Unused USDC or WETH comes back as residuals, swept to the signer.
+ */
+export const buildUniswapV3Mint = ({
+  owner,
+  usdcAmount,
+  wethAmount,
+}: UniswapV3MintInput): {
+  flow: Flow;
+  request: ComposeCompileRequest;
+} => {
+  const sdk = createComposeSdk({ baseUrl: BASE_URL, apiKey: API_KEY });
+
+  const builder = sdk.flow(1, {
+    name: 'uniswap-v3-mint-usdc-weth',
+    inputs: {
+      usdc: resources.erc20(USDC, 1),
+      weth: resources.erc20(WETH, 1),
+    },
+  });
+
+  builder.uniswapV3.mint('mint', {
+    bind: {
+      tokenA: builder.inputs.usdc,
+      tokenB: builder.inputs.weth,
+      recipient: builder.context.sender,
+    },
+    config: {
+      positionManager: POSITION_MANAGER,
+      factory: FACTORY,
+      pool: USDC_WETH_500_POOL,
+      fee: 500,
+      tickLower: TICK_LOWER,
+      tickUpper: TICK_UPPER,
+    },
+    guards: [
+      // Bound the pool price before the deposit; N bps on the sqrt price
+      // allows about 2N bps of price movement, so this caps it near 50 bps.
+      guards.band({ port: 'sqrtPriceX96', bps: 25 }),
+      // Floor the minted liquidity. Liquidity is a handle, not a resource,
+      // so no minimum appears in the response.
+      guards.slippage({ port: 'liquidity', bps: 50 }),
+    ],
+  });
+
+  const flow = builder.build();
+
+  const request = sdk.request(flow, {
+    signer: owner,
+    inputs: {
+      usdc: materialisers.directDeposit({ amount: usdcAmount }),
+      weth: materialisers.directDeposit({ amount: wethAmount }),
+    },
+    // Return unused USDC or WETH to the signer.
+    sweepTo: builder.context.sender,
+    // The position NFT is not a resource, so only the residuals count as
+    // output and the default price-impact check would read a full loss.
+    // 0 skips the check; the band and slippage guards protect the deposit.
+    maxPriceImpactBps: 0,
+  });
+
+  return { flow, request };
+};

package/src/generated/config.generated.ts

@@ -12,6 +12,10 @@ export interface CoreSplitConfig {
   bps: Between010000;
 }
 
+export interface CoreSplitAtConfig {
+  amount: IntegerStringInput;
+}
+
 /**
  * an array of at most 16 item(s)
  *
@@ -179,6 +183,10 @@ export interface CorePartitionConfig {
  * a positive number
  */
 export type Positive = number;
+/**
+ * a number between 0 and 1
+ */
+export type Between01 = number;
 /**
  * a string at most 64 character(s) long
  */
@@ -204,7 +212,7 @@ export interface LifiSwapConfig {
         token: Address;
         chainId: Positive;
       };
-  slippage?: number;
+  slippage?: Between01;
   timing?: {
     swapStepTimingStrategies?: {
       strategy: 'minWaitTime';
@@ -230,10 +238,6 @@ export interface LifiSwapConfig {
  * a string starting with "0x"
  */
 export type StartsWith0X = string;
-/**
- * a number between 0 and 1
- */
-export type Between01 = number;
 
 export interface LifiBridgeConfig {
   resourceOut:
@@ -343,9 +347,7 @@ export interface CoreBalanceOfConfig {
   owner?: Address;
 }
 
-export interface CoreTransferConfig {
-  amount?: IntegerStringInput;
-}
+export type CoreTransferConfig = Record<string, never>;
 
 export interface CoreEmitEvent1Config {
   signature: string;
@@ -1170,44 +1172,6 @@ export interface LifiFlashloanRepayConfig {
   fee?: string;
 }
 
-export type ContinuationAssertReadyConfig =
-  | {
-      kind: 'erc20BalanceGte';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      token: Address;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      owner: Address;
-      minAmount: string;
-    }
-  | {
-      kind: 'nativeBalanceGte';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      owner: Address;
-      minAmount: string;
-    }
-  | {
-      kind: 'call';
-      chainId: Positive;
-      /**
-       * EVM address: 0x followed by 40 hex characters
-       */
-      to: string;
-      /**
-       * Hex bytes: 0x followed by an even number of hex characters
-       */
-      calldata: string;
-      comparator: 'gte' | 'eq' | 'lte';
-      value: string;
-    };
-
 export interface LifiZapConfig {
   resourceOut:
     | {
@@ -1275,7 +1239,16 @@ export interface CorePeekConfig {
    */
   target: Address;
   functionSignature: string;
-  args?: string[];
+  args?: (
+    | MaxLength65536
+    | (
+        | MaxLength65536
+        | (
+            | MaxLength65536
+            | (MaxLength65536 | (MaxLength65536 | MaxLength65536[])[])[]
+          )[]
+      )[]
+  )[];
 }
 
 /**
@@ -1305,6 +1278,83 @@ export interface FlySwapConfig {
   maxSlippageBps?: Between05000;
 }
 
+export interface UniswapV2AddLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  router: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pair: string;
+}
+
+export interface UniswapV2RemoveLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  router: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  tokenA: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  tokenB: string;
+}
+
+/**
+ * a number between 0 and 999999
+ */
+export type Between0999999 = number;
+/**
+ * a number between -887272 and 887272
+ */
+export type Between887272887272 = number;
+
+export interface UniswapV3MintConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  positionManager: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pool: string;
+  fee: Between0999999;
+  tickLower: Between887272887272;
+  tickUpper: Between887272887272;
+}
+
+export interface UniswapV3IncreaseLiquidityConfig {
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  positionManager: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  factory: string;
+  /**
+   * EVM address: 0x followed by 40 hex characters
+   */
+  pool: string;
+  tokenId: string;
+}
+
 export interface SlippageGuardConfig {
   port: string;
   bps: Between010000;
@@ -1316,6 +1366,11 @@ export interface CoreNumericInvariantGuardConfig {
   threshold: IntegerStringInput;
 }
 
+export interface BandGuardConfig {
+  port: string;
+  bps: Between010000;
+}
+
 export interface BalanceOfMaterialiserConfig {
   /**
    * EVM address: 0x followed by 40 hex characters

package/src/generated/guards.generated.ts

@@ -4,6 +4,7 @@
 import type { TypedGuard } from '../types.js';
 
 import type {
+  BandGuardConfig,
   CoreNumericInvariantGuardConfig,
   SlippageGuardConfig,
 } from './config.generated.js';
@@ -23,3 +24,11 @@ export const coreNumericInvariant = <P extends string>(
   kind: 'core.numericInvariant',
   ...config,
 });
+
+/** Assert that an output stays within a tolerance in basis points of its simulated value, in both directions */
+export const band = <P extends string>(
+  config: Omit<BandGuardConfig, 'port'> & { port: P },
+): TypedGuard<P> => ({
+  kind: 'band',
+  ...config,
+});

package/src/generated/operations.generated.ts

@@ -40,6 +40,7 @@ import type {
   CorePartitionConfig,
   CorePeekConfig,
   CoreRawCallConfig,
+  CoreSplitAtConfig,
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
@@ -64,6 +65,10 @@ import type {
   MorphoBlueWithdrawCollateralConfig,
   MorphoBlueWithdrawConfig,
   ParaswapBuyConfig,
+  UniswapV2AddLiquidityConfig,
+  UniswapV2RemoveLiquidityConfig,
+  UniswapV3IncreaseLiquidityConfig,
+  UniswapV3MintConfig,
 } from './config.generated.js';
 
 /** Split a resource into two outputs by basis-point ratio. Output `a` receives `bps` of the source, rounded up, and `b` takes the remainder. */
@@ -75,6 +80,15 @@ export interface CoreSplitArgs {
   readonly guards?: readonly TypedGuard<'a' | 'b'>[];
 }
 
+/** Split a resource at a fixed amount. Output `head` receives `min(source, amount)`; `tail` receives the rest, and is 0 (omitted when unspent) when the source is at or below `amount`. */
+export interface CoreSplitAtArgs {
+  readonly bind: {
+    readonly source: Bindable<'resource'>;
+  };
+  readonly config: CoreSplitAtConfig;
+  readonly guards?: readonly TypedGuard<'head' | 'tail'>[];
+}
+
 /** Partition a resource into one output per basis-point share. `bps` lists 2 to 16 shares summing to 10000; output `parts.i` receives share i, rounded down, and the last part takes the remainder. */
 export interface CorePartitionArgs<
   TBps extends FamilySource<CorePartitionConfig['bps']> = FamilySource<
@@ -411,14 +425,14 @@ export interface CoreBalanceOfArgs {
   readonly guards?: readonly TypedGuard<'balance'>[];
 }
 
-/** Transfer tokens to a recipient address, optionally specifying a partial amount */
+/** Transfer the whole input resource to a recipient address. To send part of a resource, split it first with `core.split` or `core.splitAt`. */
 export interface CoreTransferArgs {
   readonly bind: {
     readonly amount: Bindable<'resource'>;
     readonly recipient: Bindable<'address'>;
   };
   readonly config: CoreTransferConfig;
-  readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];
+  readonly guards?: readonly TypedGuard<'transferred'>[];
 }
 
 /** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
@@ -654,11 +668,63 @@ export interface FlySwapArgs {
   readonly guards?: readonly TypedGuard<'unspentIn'>[];
 }
 
+/** Deposit two ERC-20 tokens into an existing Uniswap V2 pair (or an ABI-identical fork such as SushiSwap V2) through its Router02 and receive the pair's LP token; unused input returns as residuals. Asserts on chain that the router's factory is `factory`, that the factory's pair for the two tokens is `pair`, and that the pair holds non-zero reserves. Exposes the pool price read before the deposit as `poolPrice`. The deposit is protected only with a `band` guard on `poolPrice` and a `slippage` guard on `liquidity`. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV2AddLiquidityArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+  };
+  readonly config: UniswapV2AddLiquidityConfig;
+  readonly guards?: readonly TypedGuard<
+    'liquidity' | 'residualA' | 'residualB' | 'poolPrice'
+  >[];
+}
+
+/** Burn a Uniswap V2 LP token (or one of an ABI-identical fork such as SushiSwap V2) through its Router02 and receive both underlying tokens. Asserts on chain that the router's factory is `factory` and that the factory's pair for `tokenA`/`tokenB` is the input LP token. The withdrawal is protected only with a `slippage` guard on each of `tokenA` and `tokenB`. Fee-on-transfer tokens are unsupported: the outputs are the amounts the router reports, which would overstate what such a token delivers. */
+export interface UniswapV2RemoveLiquidityArgs {
+  readonly bind: {
+    readonly liquidity: Bindable<'resource'>;
+  };
+  readonly config: UniswapV2RemoveLiquidityConfig;
+  readonly guards?: readonly TypedGuard<'tokenA' | 'tokenB'>[];
+}
+
+/** Open a Uniswap V3 concentrated-liquidity position (or one on an ABI-identical fork) for a tick range, minting the position NFT straight to `recipient`, which must not be the execution address. Exposes the new `tokenId`; unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV3MintArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+    readonly recipient: Bindable<'address'>;
+  };
+  readonly config: UniswapV3MintConfig;
+  readonly guards?: readonly TypedGuard<
+    'tokenId' | 'liquidity' | 'sqrtPriceX96' | 'residualA' | 'residualB'
+  >[];
+}
+
+/** Add two tokens to an existing Uniswap V3 position (or one on an ABI-identical fork). `owner` must own `tokenId`, and the position must hold the two input tokens; both are asserted on chain, since the position manager checks neither. Unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. */
+export interface UniswapV3IncreaseLiquidityArgs {
+  readonly bind: {
+    readonly tokenA: Bindable<'resource'>;
+    readonly tokenB: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+  };
+  readonly config: UniswapV3IncreaseLiquidityConfig;
+  readonly guards?: readonly TypedGuard<
+    'liquidity' | 'sqrtPriceX96' | 'residualA' | 'residualB'
+  >[];
+}
+
 export interface CoreSplitOutputs {
   readonly a: OutputHandle<'resource'>;
   readonly b: OutputHandle<'resource'>;
 }
 
+export interface CoreSplitAtOutputs {
+  readonly head: OutputHandle<'resource'>;
+  readonly tail: OutputHandle<'resource'>;
+}
+
 export interface CorePartitionOutputs<
   TBps extends FamilySource<CorePartitionConfig['bps']> = FamilySource<
     CorePartitionConfig['bps']
@@ -715,7 +781,6 @@ export interface CoreBalanceOfOutputs {
 
 export interface CoreTransferOutputs {
   readonly transferred: OutputHandle<'resource'>;
-  readonly remainder: OutputHandle<'resource'>;
 }
 
 export interface CoreRawCallOutputs {
@@ -807,10 +872,42 @@ export interface FlySwapOutputs {
   readonly unspentIn: OutputHandle<'resource'>;
 }
 
+export interface UniswapV2AddLiquidityOutputs {
+  readonly liquidity: OutputHandle<'resource'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+  readonly poolPrice: OutputHandle<'uint256'>;
+}
+
+export interface UniswapV2RemoveLiquidityOutputs {
+  readonly tokenA: OutputHandle<'resource'>;
+  readonly tokenB: OutputHandle<'resource'>;
+}
+
+export interface UniswapV3MintOutputs {
+  readonly tokenId: OutputHandle<'uint256'>;
+  readonly liquidity: OutputHandle<'uint256'>;
+  readonly sqrtPriceX96: OutputHandle<'uint256'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+}
+
+export interface UniswapV3IncreaseLiquidityOutputs {
+  readonly liquidity: OutputHandle<'uint256'>;
+  readonly sqrtPriceX96: OutputHandle<'uint256'>;
+  readonly residualA: OutputHandle<'resource'>;
+  readonly residualB: OutputHandle<'resource'>;
+}
+
 export type GeneratedOps = {
   readonly core: {
     /** Split a resource into two outputs by basis-point ratio. Output `a` receives `bps` of the source, rounded up, and `b` takes the remainder. — original id: "core.split" */
     readonly split: (nodeId: string, args: CoreSplitArgs) => CoreSplitOutputs;
+    /** Split a resource at a fixed amount. Output `head` receives `min(source, amount)`; `tail` receives the rest, and is 0 (omitted when unspent) when the source is at or below `amount`. — original id: "core.splitAt" */
+    readonly splitAt: (
+      nodeId: string,
+      args: CoreSplitAtArgs,
+    ) => CoreSplitAtOutputs;
     /** Partition a resource into one output per basis-point share. `bps` lists 2 to 16 shares summing to 10000; output `parts.i` receives share i, rounded down, and the last part takes the remainder. — original id: "core.partition" */
     readonly partition: <
       const TBps extends FamilySource<CorePartitionConfig['bps']>,
@@ -876,7 +973,7 @@ export type GeneratedOps = {
       nodeId: string,
       args: CoreBalanceOfArgs,
     ) => CoreBalanceOfOutputs;
-    /** Transfer tokens to a recipient address, optionally specifying a partial amount — original id: "core.transfer" */
+    /** Transfer the whole input resource to a recipient address. To send part of a resource, split it first with `core.split` or `core.splitAt`. — original id: "core.transfer" */
     readonly transfer: (
       nodeId: string,
       args: CoreTransferArgs,
@@ -1060,6 +1157,30 @@ export type GeneratedOps = {
     /** Swap via Fly's DexAggregator, sized at runtime: the router calldata leaves `amountIn` unset, so an upstream op's output can feed the swap without being known at plan time. Either leg may be the chain-native coin. — original id: "fly.swap" */
     readonly swap: (nodeId: string, args: FlySwapArgs) => FlySwapOutputs;
   };
+  readonly uniswapV2: {
+    /** Deposit two ERC-20 tokens into an existing Uniswap V2 pair (or an ABI-identical fork such as SushiSwap V2) through its Router02 and receive the pair's LP token; unused input returns as residuals. Asserts on chain that the router's factory is `factory`, that the factory's pair for the two tokens is `pair`, and that the pair holds non-zero reserves. Exposes the pool price read before the deposit as `poolPrice`. The deposit is protected only with a `band` guard on `poolPrice` and a `slippage` guard on `liquidity`. Fee-on-transfer tokens are unsupported. — original id: "uniswapV2.addLiquidity" */
+    readonly addLiquidity: (
+      nodeId: string,
+      args: UniswapV2AddLiquidityArgs,
+    ) => UniswapV2AddLiquidityOutputs;
+    /** Burn a Uniswap V2 LP token (or one of an ABI-identical fork such as SushiSwap V2) through its Router02 and receive both underlying tokens. Asserts on chain that the router's factory is `factory` and that the factory's pair for `tokenA`/`tokenB` is the input LP token. The withdrawal is protected only with a `slippage` guard on each of `tokenA` and `tokenB`. Fee-on-transfer tokens are unsupported: the outputs are the amounts the router reports, which would overstate what such a token delivers. — original id: "uniswapV2.removeLiquidity" */
+    readonly removeLiquidity: (
+      nodeId: string,
+      args: UniswapV2RemoveLiquidityArgs,
+    ) => UniswapV2RemoveLiquidityOutputs;
+  };
+  readonly uniswapV3: {
+    /** Open a Uniswap V3 concentrated-liquidity position (or one on an ABI-identical fork) for a tick range, minting the position NFT straight to `recipient`, which must not be the execution address. Exposes the new `tokenId`; unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. — original id: "uniswapV3.mint" */
+    readonly mint: (
+      nodeId: string,
+      args: UniswapV3MintArgs,
+    ) => UniswapV3MintOutputs;
+    /** Add two tokens to an existing Uniswap V3 position (or one on an ABI-identical fork). `owner` must own `tokenId`, and the position must hold the two input tokens; both are asserted on chain, since the position manager checks neither. Unused input comes back as residuals. The deposit is protected only with a `band` guard on `sqrtPriceX96` (read before the deposit) and a `slippage` guard on `liquidity`; a band of N bps on `sqrtPriceX96` allows about 2N bps of price movement. Fee-on-transfer tokens are unsupported. — original id: "uniswapV3.increaseLiquidity" */
+    readonly increaseLiquidity: (
+      nodeId: string,
+      args: UniswapV3IncreaseLiquidityArgs,
+    ) => UniswapV3IncreaseLiquidityOutputs;
+  };
 };
 
 export const bindGeneratedOps = (
@@ -1071,6 +1192,11 @@ export const bindGeneratedOps = (
         a: 'resource',
         b: 'resource',
       } as const),
+    splitAt: (nodeId: string, args: CoreSplitAtArgs) =>
+      builder.call(nodeId, 'core.splitAt', args, {
+        head: 'resource',
+        tail: 'resource',
+      } as const),
     partition: <const TBps extends FamilySource<CorePartitionConfig['bps']>>(
       nodeId: string,
       args: CorePartitionArgs<TBps>,
@@ -1135,7 +1261,6 @@ export const bindGeneratedOps = (
     transfer: (nodeId: string, args: CoreTransferArgs) =>
       builder.call(nodeId, 'core.transfer', args, {
         transferred: 'resource',
-        remainder: 'resource',
       } as const),
     emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) =>
       builder.call(nodeId, 'core.emitEvent1', args, {}),
@@ -1359,4 +1484,35 @@ export const bindGeneratedOps = (
         unspentIn: 'resource',
       } as const),
   },
+  uniswapV2: {
+    addLiquidity: (nodeId: string, args: UniswapV2AddLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV2.addLiquidity', args, {
+        liquidity: 'resource',
+        residualA: 'resource',
+        residualB: 'resource',
+        poolPrice: 'uint256',
+      } as const),
+    removeLiquidity: (nodeId: string, args: UniswapV2RemoveLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV2.removeLiquidity', args, {
+        tokenA: 'resource',
+        tokenB: 'resource',
+      } as const),
+  },
+  uniswapV3: {
+    mint: (nodeId: string, args: UniswapV3MintArgs) =>
+      builder.call(nodeId, 'uniswapV3.mint', args, {
+        tokenId: 'uint256',
+        liquidity: 'uint256',
+        sqrtPriceX96: 'uint256',
+        residualA: 'resource',
+        residualB: 'resource',
+      } as const),
+    increaseLiquidity: (nodeId: string, args: UniswapV3IncreaseLiquidityArgs) =>
+      builder.call(nodeId, 'uniswapV3.increaseLiquidity', args, {
+        liquidity: 'uint256',
+        sqrtPriceX96: 'uint256',
+        residualA: 'resource',
+        residualB: 'resource',
+      } as const),
+  },
 });

package/src/index.ts

@@ -99,11 +99,8 @@ export type {
   Erc20AllowanceRequirement,
   ContinuationIntent,
   ContinuationOutcome,
-  Check,
-  CheckComparator,
   SettlementWire,
   SettlementEscrowWire,
-  ContinuationPlanWire,
 } from '@lifi/compose-spec';
 export {
   SIMULATE_MAX_TRACKED_BALANCES,

package/dist/discovery.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/discovery.ts"],"sourcesContent":["/**\n * Types for the Compose discovery API (`GET /compose/zap-packs`, `GET /chains`).\n *\n * These are SDK-facing presentation types — not part of the core compile\n * contract in compose-spec. The backend response is the source of truth;\n * the SDK provides typed access.\n *\n * The `type` field on edges is a plain `string` rather than a strict union\n * so the SDK remains forward-compatible when the backend introduces new\n * edge types. Known values at time of writing:\n * `\"enter-position\"`, `\"exit-position\"`, `\"wrap\"`, `\"unwrap\"`, `\"mint\"`, `\"burn\"`.\n */\n\n/**\n * A chain the Compose deployment supports.\n */\nexport interface ChainSummary {\n  /** EVM chain ID. The stable identifier — key on this. */\n  readonly chainId: number;\n  /**\n   * Human-readable label, suitable for display in a chain selector.\n   *\n   * Maintained by the deployment rather than derived from canonical chain\n   * branding, so it can differ from a chain's marketed name and can change\n   * without notice. Never treat it as an identifier, and never match on it.\n   * A chain the deployment has no configured label for reports `Chain <id>`.\n   */\n  readonly name: string;\n}\n\n/**\n * A single routing edge representing a supported token-to-token path\n * through a DeFi protocol.\n */\nexport interface ZapPackEdge {\n  /** Edge type (e.g. `\"enter-position\"`, `\"exit-position\"`, `\"wrap\"`). */\n  readonly type: string;\n  /** Input token. */\n  readonly in: { readonly address: string; readonly chainId: number };\n  /** Output token. */\n  readonly out: { readonly address: string; readonly chainId: number };\n  /** Minimum input amount accepted (stringified integer), if constrained. */\n  readonly inAmountMin?: string;\n  /** Maximum input amount accepted (stringified integer), if constrained. */\n  readonly inAmountMax?: string;\n  /**\n   * Recipient binding obligation. `\"required\"` means the zap must bind its\n   * `recipient` input. The output is externally owned, terminal, and unswept.\n   * The loose string type preserves forward compatibility with new values.\n   */\n  readonly recipient?: string;\n  /**\n   * Output availability. `\"future\"` means the output becomes available only\n   * after the initiating transaction settles; route via `lifi.zapAsync` with\n   * a bound recipient. Absent means the output is available synchronously.\n   * The loose string type preserves forward compatibility with new values.\n   */\n  readonly availability?: string;\n}\n\n/**\n * All routing edges for a single protocol.\n */\nexport interface ZapPackOverview {\n  /** Protocol identifier (e.g. `\"aave\"`, `\"morpho\"`). */\n  readonly protocol: string;\n  /** Available routing edges for this protocol. */\n  readonly edges: readonly ZapPackEdge[];\n}\n\n/**\n * Options for {@link ComposeClient.getZapPacks}.\n */\nexport interface GetZapPacksOptions {\n  /**\n   * Filter to specific protocols. Pass a single string or an array.\n   * Only edges belonging to the listed protocols are returned.\n   * Omit to fetch all available protocols.\n   */\n  readonly protocols?: string | readonly string[];\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/discovery.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}