@lifi/composer-sdk 0.6.3 → 0.7.0

package/src/authoring/handles.ts

@@ -39,6 +39,73 @@ export interface OutputHandle<T extends OutputKind = OutputKind> {
   readonly __outputKind?: T;
 }
 
+/**
+ * What an output family's sizing parameter accepts, given the config field the
+ * family counts from: an array of that field's elements, or a number.
+ */
+export type FamilySource<Field> = Field extends readonly (infer E)[]
+  ? readonly E[]
+  : number;
+
+/** Whether a number literal is a valid family count: a non-negative integer. */
+type IsCountLiteral<N extends number> = `${N}` extends
+  `-${string}` | `${string}.${string}` | `${string}e${string}`
+  ? false
+  : true;
+
+/**
+ * `N` resource handles as a tuple. A non-literal `number`, or a literal that is
+ * not a valid count, gives an open array; {@link FamilyCount} rejects the
+ * invalid literal at the call site.
+ */
+type HandleTuple<
+  N extends number,
+  Acc extends readonly OutputHandle<'resource'>[] = readonly [],
+> = number extends N
+  ? readonly OutputHandle<'resource'>[]
+  : IsCountLiteral<N> extends false
+    ? readonly OutputHandle<'resource'>[]
+    : Acc['length'] extends N
+      ? Acc
+      : HandleTuple<N, readonly [...Acc, OutputHandle<'resource'>]>;
+
+/**
+ * The handles of an output family: one resource {@link OutputHandle} per
+ * element of the config array the family counts from, or as many as the config
+ * count. A literal array or count yields a tuple of that length, so indexing
+ * past the last instance is a type error.
+ */
+export type OutputFamilyHandles<TCount extends readonly unknown[] | number> =
+  TCount extends readonly unknown[]
+    ? { readonly [I in keyof TCount]: OutputHandle<'resource'> }
+    : TCount extends number
+      ? HandleTuple<TCount>
+      : never;
+
+/**
+ * Holds the config value an output family counts from to the op's own type. A
+ * runtime-sized array or count passes as is. A literal tuple must also satisfy
+ * `Shape`, so a tuple shorter than the op's `minItems` fails at the call site
+ * instead of at the server's bind step. A literal count must be a non-negative
+ * integer.
+ */
+export type FamilyCount<
+  TCount extends readonly unknown[] | number,
+  Shape,
+> = TCount extends readonly unknown[]
+  ? number extends TCount['length']
+    ? unknown
+    : TCount extends Shape
+      ? unknown
+      : { readonly 'output family config array has too few entries': never }
+  : TCount extends number
+    ? IsCountLiteral<TCount> extends true
+      ? unknown
+      : {
+          readonly 'output family count must be a non-negative integer': never;
+        }
+    : unknown;
+
 /** Discriminated union of all handle types that can be bound to operation arguments. */
 export type AnyHandle = InputHandle | OutputHandle;
 

package/src/examples/splitAndZap.ts

@@ -18,8 +18,8 @@ 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
+ * - core.partition to divide a resource into one part per basis-point share
+ * - Destructuring the typed `parts` tuple into two independent lifi.zap nodes
  * - Slippage guards on both zap outputs
  */
 export const buildSplitAndZapExample = (): {
@@ -35,15 +35,16 @@ export const buildSplitAndZapExample = (): {
     },
   });
 
-  // Split USDC 60/40 — 6000 bps to `a`, remainder to `b`.
-  const { a, b } = builder.core.split('split', {
+  // Partition USDC 60/40 — one part per `bps` entry. Every part but the last
+  // is rounded down; the last takes the remainder.
+  const [toAave, toMorpho] = builder.core.partition('split', {
     bind: { source: builder.inputs.amountIn },
-    config: { bps: 6000 },
-  });
+    config: { bps: [6000, 4000] },
+  }).parts;
 
   // Zap 60% into Aave v3 aEthUSDC.
   builder.lifi.zap('zap-aave', {
-    bind: { amountIn: a },
+    bind: { amountIn: toAave },
     config: {
       resourceOut: resources.erc20(A_ETH_USDC, 1),
     },
@@ -52,7 +53,7 @@ export const buildSplitAndZapExample = (): {
 
   // Zap 40% into Steakhouse USDC (Morpho).
   builder.lifi.zap('zap-morpho', {
-    bind: { amountIn: b },
+    bind: { amountIn: toMorpho },
     config: {
       resourceOut: resources.erc20(STEAKHOUSE_USDC, 1),
     },