@lifi/composer-sdk 0.0.1-alpha → 0.2.0-staging.3

package/src/generated/operations.generated.ts

@@ -18,6 +18,12 @@ import {
 import type { TypedGuard } from '../types.js';
 
 import type {
+  AaveBorrowConfig,
+  AaveClaimRewardsConfig,
+  AaveGetHealthFactorConfig,
+  AaveRepayConfig,
+  AaveRepayWithATokensConfig,
+  AaveSetEModeConfig,
   CoreApproveConfig,
   CoreAsResourceConfig,
   CoreBalanceOfConfig,
@@ -29,8 +35,17 @@ import type {
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
+  LifiFlashloanRepayConfig,
   LifiSwapConfig,
   LifiZapConfig,
+  MorphoBlueBorrowConfig,
+  MorphoBlueGetPositionConfig,
+  MorphoBlueRepayConfig,
+  MorphoBlueSupplyCollateralConfig,
+  MorphoBlueSupplyConfig,
+  MorphoBlueWithdrawCollateralConfig,
+  MorphoBlueWithdrawConfig,
+  ParaswapBuyConfig,
 } from './config.generated.js';
 
 /** Split a resource into two outputs by basis-point ratio */
@@ -69,15 +84,6 @@ export interface InvariantBalanceAtLeastArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
-/** Route tokens into a DeFi protocol position via the edge catalog */
-export interface LifiZapArgs {
-  readonly bind: {
-    readonly amountIn: Bindable<'resource'>;
-  };
-  readonly config: LifiZapConfig;
-  readonly guards?: readonly TypedGuard<'amountOut'>[];
-}
-
 /** Add two unsigned integers (a + b) */
 export interface CoreAddArgs {
   readonly bind: {
@@ -266,6 +272,145 @@ export interface CoreAsResourceArgs {
   readonly guards?: readonly TypedGuard<'resource'>[];
 }
 
+/** Borrow an asset from an Aave v3 pool against existing collateral, exposing the borrowed asset as a Resource */
+export interface AaveBorrowArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveBorrowConfig;
+  readonly guards?: readonly TypedGuard<'debtBalance'>[];
+}
+
+/** Repay an Aave v3 variable-rate debt position with the supplied asset. mode: 'exact' passes the input handle amount; mode: 'max' passes type(uint256).max so Aave's Pool clamps paybackAmount to userVariableDebt exactly. Any unspent input is returned through the residual port. */
+export interface AaveRepayArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+    readonly onBehalfOf: Bindable<'address'>;
+  };
+  readonly config: AaveRepayConfig;
+  readonly guards?: readonly TypedGuard<'actualRepaid' | 'residual'>[];
+}
+
+/** Repay an Aave v3 variable-rate debt by burning the caller's aToken balance, returning any unspent residual */
+export interface AaveRepayWithATokensArgs {
+  readonly bind: {
+    readonly aTokenIn: Bindable<'resource'>;
+  };
+  readonly config: AaveRepayWithATokensConfig;
+  readonly guards?: readonly TypedGuard<'actualRepaid' | 'residual'>[];
+}
+
+/** Claim a specific Aave v3 incentives reward token against a set of receipt-token positions, exposing the claimed amount as a Resource */
+export interface AaveClaimRewardsArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveClaimRewardsConfig;
+  readonly guards?: readonly TypedGuard<'claimedAmount'>[];
+}
+
+/** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. */
+export interface AaveSetEModeArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveSetEModeConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. */
+export interface AaveGetHealthFactorArgs {
+  readonly bind: Record<string, never>;
+  readonly config: AaveGetHealthFactorConfig;
+  readonly guards?: readonly TypedGuard<'healthFactor'>[];
+}
+
+/** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). */
+export interface MorphoBlueSupplyCollateralArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+  };
+  readonly config: MorphoBlueSupplyCollateralConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Withdraw collateral from a Morpho Blue market position to the receiver address. Exposes the withdrawn ERC20 amount as a Resource output. */
+export interface MorphoBlueWithdrawCollateralArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueWithdrawCollateralConfig;
+  readonly guards?: readonly TypedGuard<'collateralWithdrawn'>[];
+}
+
+/** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. */
+export interface MorphoBlueBorrowArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueBorrowConfig;
+  readonly guards?: readonly TypedGuard<'assetsBorrowed' | 'sharesBorrowed'>[];
+}
+
+/** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. */
+export interface MorphoBlueRepayArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+    readonly onBehalfOf: Bindable<'address'>;
+  };
+  readonly config: MorphoBlueRepayConfig;
+  readonly guards?: readonly TypedGuard<
+    'actualRepaid' | 'sharesRepaid' | 'residual'
+  >[];
+}
+
+/** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. */
+export interface MorphoBlueSupplyArgs {
+  readonly bind: {
+    readonly assetIn: Bindable<'resource'>;
+  };
+  readonly config: MorphoBlueSupplyConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsSupplied' | 'sharesSupplied' | 'residual'
+  >[];
+}
+
+/** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. */
+export interface MorphoBlueWithdrawArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueWithdrawConfig;
+  readonly guards?: readonly TypedGuard<
+    'assetsWithdrawn' | 'sharesWithdrawn'
+  >[];
+}
+
+/** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). */
+export interface MorphoBlueGetPositionArgs {
+  readonly bind: Record<string, never>;
+  readonly config: MorphoBlueGetPositionConfig;
+  readonly guards?: readonly TypedGuard<
+    'supplyShares' | 'borrowShares' | 'collateral'
+  >[];
+}
+
+/** Transfer principal + fee back to the LiFi flashloan adapter for one leg */
+export interface LifiFlashloanRepayArgs {
+  readonly bind: {
+    readonly funds: Bindable<'resource'>;
+    readonly feeBuffer?: Bindable<'resource'>;
+  };
+  readonly config: LifiFlashloanRepayConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Route tokens into a DeFi protocol position via the edge catalog */
+export interface LifiZapArgs {
+  readonly bind: {
+    readonly amountIn: Bindable<'resource'>;
+  };
+  readonly config: LifiZapConfig;
+  readonly guards?: readonly TypedGuard<'amountOut'>[];
+}
+
+/** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. */
+export interface ParaswapBuyArgs {
+  readonly bind: {
+    readonly amountIn: Bindable<'resource'>;
+  };
+  readonly config: ParaswapBuyConfig;
+  readonly guards?: readonly TypedGuard<'unspentIn'>[];
+}
+
 /** Read a smart contract value at compile time (off-chain eth_call); result is baked as a literal */
 export interface CorePeekArgs {
   readonly bind: Record<string, never>;
@@ -287,10 +432,6 @@ export interface LifiSwapOutputs {
   readonly unspentIn: OutputHandle<'resource'>;
 }
 
-export interface LifiZapOutputs {
-  readonly amountOut: OutputHandle<'resource'>;
-}
-
 export interface CoreAddOutputs {
   readonly result: OutputHandle<'uint256'>;
 }
@@ -336,6 +477,74 @@ export interface CoreAsResourceOutputs {
   readonly resource: OutputHandle<'resource'>;
 }
 
+export interface AaveBorrowOutputs {
+  readonly borrowed: OutputHandle<'resource'>;
+  readonly debtBalance: OutputHandle<'uint256'>;
+}
+
+export interface AaveRepayOutputs {
+  readonly actualRepaid: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface AaveRepayWithATokensOutputs {
+  readonly actualRepaid: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface AaveClaimRewardsOutputs {
+  readonly claimed: OutputHandle<'resource'>;
+  readonly claimedAmount: OutputHandle<'uint256'>;
+}
+
+export interface AaveGetHealthFactorOutputs {
+  readonly healthFactor: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueWithdrawCollateralOutputs {
+  readonly withdrawn: OutputHandle<'resource'>;
+  readonly collateralWithdrawn: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueBorrowOutputs {
+  readonly borrowed: OutputHandle<'resource'>;
+  readonly assetsBorrowed: OutputHandle<'uint256'>;
+  readonly sharesBorrowed: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueRepayOutputs {
+  readonly actualRepaid: OutputHandle<'uint256'>;
+  readonly sharesRepaid: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueSupplyOutputs {
+  readonly assetsSupplied: OutputHandle<'uint256'>;
+  readonly sharesSupplied: OutputHandle<'uint256'>;
+  readonly residual: OutputHandle<'resource'>;
+}
+
+export interface MorphoBlueWithdrawOutputs {
+  readonly withdrawn: OutputHandle<'resource'>;
+  readonly assetsWithdrawn: OutputHandle<'uint256'>;
+  readonly sharesWithdrawn: OutputHandle<'uint256'>;
+}
+
+export interface MorphoBlueGetPositionOutputs {
+  readonly supplyShares: OutputHandle<'uint256'>;
+  readonly borrowShares: OutputHandle<'uint128'>;
+  readonly collateral: OutputHandle<'uint128'>;
+}
+
+export interface LifiZapOutputs {
+  readonly amountOut: OutputHandle<'resource'>;
+}
+
+export interface ParaswapBuyOutputs {
+  readonly amountOut: OutputHandle<'resource'>;
+  readonly unspentIn: OutputHandle<'resource'>;
+}
+
 export interface CorePeekOutputs {
   readonly result: OutputHandle<'uint256'>;
 }
@@ -433,6 +642,11 @@ export type GeneratedOps = {
   readonly lifi: {
     /** Swap tokens via the LI.FI aggregator API — original id: "lifi.swap" */
     readonly swap: (nodeId: string, args: LifiSwapArgs) => LifiSwapOutputs;
+    /** Transfer principal + fee back to the LiFi flashloan adapter for one leg — original id: "lifi.flashloanRepay" */
+    readonly flashloanRepay: (
+      nodeId: string,
+      args: LifiFlashloanRepayArgs,
+    ) => void;
     /** Route tokens into a DeFi protocol position via the edge catalog — original id: "lifi.zap" */
     readonly zap: (nodeId: string, args: LifiZapArgs) => LifiZapOutputs;
   };
@@ -443,6 +657,73 @@ export type GeneratedOps = {
       args: InvariantBalanceAtLeastArgs,
     ) => void;
   };
+  readonly aave: {
+    /** Borrow an asset from an Aave v3 pool against existing collateral, exposing the borrowed asset as a Resource — original id: "aave.borrow" */
+    readonly borrow: (
+      nodeId: string,
+      args: AaveBorrowArgs,
+    ) => AaveBorrowOutputs;
+    /** Repay an Aave v3 variable-rate debt position with the supplied asset. mode: 'exact' passes the input handle amount; mode: 'max' passes type(uint256).max so Aave's Pool clamps paybackAmount to userVariableDebt exactly. Any unspent input is returned through the residual port. — original id: "aave.repay" */
+    readonly repay: (nodeId: string, args: AaveRepayArgs) => AaveRepayOutputs;
+    /** Repay an Aave v3 variable-rate debt by burning the caller's aToken balance, returning any unspent residual — original id: "aave.repayWithATokens" */
+    readonly repayWithATokens: (
+      nodeId: string,
+      args: AaveRepayWithATokensArgs,
+    ) => AaveRepayWithATokensOutputs;
+    /** Claim a specific Aave v3 incentives reward token against a set of receipt-token positions, exposing the claimed amount as a Resource — original id: "aave.claimRewards" */
+    readonly claimRewards: (
+      nodeId: string,
+      args: AaveClaimRewardsArgs,
+    ) => AaveClaimRewardsOutputs;
+    /** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. — original id: "aave.setEMode" */
+    readonly setEMode: (nodeId: string, args: AaveSetEModeArgs) => void;
+    /** Read the current Aave v3 health factor (WAD-scaled, 1e18; type(uint256).max for users with no debt) by static-calling IPool.getUserAccountData and decomposing the returned tuple. Exposes the healthFactor element as a uint256 handle suitable for use with core.numericInvariant. — original id: "aave.getHealthFactor" */
+    readonly getHealthFactor: (
+      nodeId: string,
+      args: AaveGetHealthFactorArgs,
+    ) => AaveGetHealthFactorOutputs;
+  };
+  readonly morphoBlue: {
+    /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). — original id: "morphoBlue.supplyCollateral" */
+    readonly supplyCollateral: (
+      nodeId: string,
+      args: MorphoBlueSupplyCollateralArgs,
+    ) => void;
+    /** Withdraw collateral from a Morpho Blue market position to the receiver address. Exposes the withdrawn ERC20 amount as a Resource output. — original id: "morphoBlue.withdrawCollateral" */
+    readonly withdrawCollateral: (
+      nodeId: string,
+      args: MorphoBlueWithdrawCollateralArgs,
+    ) => MorphoBlueWithdrawCollateralOutputs;
+    /** Borrow the loan asset from a Morpho Blue market against existing collateral. Exposes the borrowed amount as a Resource and the (assetsBorrowed, sharesBorrowed) tuple as handles. — original id: "morphoBlue.borrow" */
+    readonly borrow: (
+      nodeId: string,
+      args: MorphoBlueBorrowArgs,
+    ) => MorphoBlueBorrowOutputs;
+    /** Repay a Morpho Blue debt position with the supplied asset. mode: 'exact' repays the input handle amount; mode: 'max' reads Position.borrowShares via a precursor static call and repays in shares mode to retire the debt to the wei. Returns any unspent residual as a Resource. — original id: "morphoBlue.repay" */
+    readonly repay: (
+      nodeId: string,
+      args: MorphoBlueRepayArgs,
+    ) => MorphoBlueRepayOutputs;
+    /** Supply the loan asset of a Morpho Blue market and receive supplyShares accounting credit. Returns the (assetsSupplied, sharesSupplied) tuple as handles and any unspent residual as a Resource. — original id: "morphoBlue.supply" */
+    readonly supply: (
+      nodeId: string,
+      args: MorphoBlueSupplyArgs,
+    ) => MorphoBlueSupplyOutputs;
+    /** Withdraw the loan asset from a Morpho Blue supply position. mode: 'exact' withdraws the configured amount; mode: 'max' reads Position.supplyShares via a precursor static call and burns all shares to retire the supply to the wei. Exposes the withdrawn amount as a Resource. — original id: "morphoBlue.withdraw" */
+    readonly withdraw: (
+      nodeId: string,
+      args: MorphoBlueWithdrawArgs,
+    ) => MorphoBlueWithdrawOutputs;
+    /** Read a Morpho Blue Position struct via a static call on the singleton. Exposes (supplyShares, borrowShares, collateral) as handles whose kinds match the on-chain field types (uint256, uint128, uint128). — original id: "morphoBlue.getPosition" */
+    readonly getPosition: (
+      nodeId: string,
+      args: MorphoBlueGetPositionArgs,
+    ) => MorphoBlueGetPositionOutputs;
+  };
+  readonly paraswap: {
+    /** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. — original id: "paraswap.buy" */
+    readonly buy: (nodeId: string, args: ParaswapBuyArgs) => ParaswapBuyOutputs;
+  };
 };
 
 export const bindGeneratedOps = (
@@ -551,6 +832,8 @@ export const bindGeneratedOps = (
         amountOut: 'resource',
         unspentIn: 'resource',
       } as const),
+    flashloanRepay: (nodeId: string, args: LifiFlashloanRepayArgs) =>
+      builder.call(nodeId, 'lifi.flashloanRepay', args, {}),
     zap: (nodeId: string, args: LifiZapArgs) =>
       builder.call(nodeId, 'lifi.zap', args, {
         amountOut: 'resource',
@@ -565,4 +848,81 @@ export const bindGeneratedOps = (
         {},
       ),
   },
+  aave: {
+    borrow: (nodeId: string, args: AaveBorrowArgs) =>
+      builder.call(nodeId, 'aave.borrow', args, {
+        borrowed: 'resource',
+        debtBalance: 'uint256',
+      } as const),
+    repay: (nodeId: string, args: AaveRepayArgs) =>
+      builder.call(nodeId, 'aave.repay', args, {
+        actualRepaid: 'uint256',
+        residual: 'resource',
+      } as const),
+    repayWithATokens: (nodeId: string, args: AaveRepayWithATokensArgs) =>
+      builder.call(nodeId, 'aave.repayWithATokens', args, {
+        actualRepaid: 'uint256',
+        residual: 'resource',
+      } as const),
+    claimRewards: (nodeId: string, args: AaveClaimRewardsArgs) =>
+      builder.call(nodeId, 'aave.claimRewards', args, {
+        claimed: 'resource',
+        claimedAmount: 'uint256',
+      } as const),
+    setEMode: (nodeId: string, args: AaveSetEModeArgs) =>
+      builder.call(nodeId, 'aave.setEMode', args, {}),
+    getHealthFactor: (nodeId: string, args: AaveGetHealthFactorArgs) =>
+      builder.call(nodeId, 'aave.getHealthFactor', args, {
+        healthFactor: 'uint256',
+      } as const),
+  },
+  morphoBlue: {
+    supplyCollateral: (nodeId: string, args: MorphoBlueSupplyCollateralArgs) =>
+      builder.call(nodeId, 'morphoBlue.supplyCollateral', args, {}),
+    withdrawCollateral: (
+      nodeId: string,
+      args: MorphoBlueWithdrawCollateralArgs,
+    ) =>
+      builder.call(nodeId, 'morphoBlue.withdrawCollateral', args, {
+        withdrawn: 'resource',
+        collateralWithdrawn: 'uint256',
+      } as const),
+    borrow: (nodeId: string, args: MorphoBlueBorrowArgs) =>
+      builder.call(nodeId, 'morphoBlue.borrow', args, {
+        borrowed: 'resource',
+        assetsBorrowed: 'uint256',
+        sharesBorrowed: 'uint256',
+      } as const),
+    repay: (nodeId: string, args: MorphoBlueRepayArgs) =>
+      builder.call(nodeId, 'morphoBlue.repay', args, {
+        actualRepaid: 'uint256',
+        sharesRepaid: 'uint256',
+        residual: 'resource',
+      } as const),
+    supply: (nodeId: string, args: MorphoBlueSupplyArgs) =>
+      builder.call(nodeId, 'morphoBlue.supply', args, {
+        assetsSupplied: 'uint256',
+        sharesSupplied: 'uint256',
+        residual: 'resource',
+      } as const),
+    withdraw: (nodeId: string, args: MorphoBlueWithdrawArgs) =>
+      builder.call(nodeId, 'morphoBlue.withdraw', args, {
+        withdrawn: 'resource',
+        assetsWithdrawn: 'uint256',
+        sharesWithdrawn: 'uint256',
+      } as const),
+    getPosition: (nodeId: string, args: MorphoBlueGetPositionArgs) =>
+      builder.call(nodeId, 'morphoBlue.getPosition', args, {
+        supplyShares: 'uint256',
+        borrowShares: 'uint128',
+        collateral: 'uint128',
+      } as const),
+  },
+  paraswap: {
+    buy: (nodeId: string, args: ParaswapBuyArgs) =>
+      builder.call(nodeId, 'paraswap.buy', args, {
+        amountOut: 'resource',
+        unspentIn: 'resource',
+      } as const),
+  },
 });

package/src/run/inputs.ts

@@ -33,6 +33,13 @@ export interface ComposeRunInput<T extends InputSchema = InputSchema> {
   readonly assumptions?: { readonly [K in keyof T]?: bigint };
   /** Optional integrator referrer identifier. */
   readonly referrer?: string;
+  /**
+   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
+   * A non-zero value requires the request to be authenticated with an
+   * integration-scoped API key — the integration is derived from the key, not
+   * this field. Defaults to `0` (no fee) when omitted.
+   */
+  readonly integratorFeeBps?: number;
   /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
   readonly maxPriceImpactBps?: number;
   /**
@@ -94,6 +101,7 @@ export const buildRun = (run: {
   signer: string;
   assumptions?: Record<string, bigint>;
   referrer?: string;
+  integratorFeeBps?: number;
   maxPriceImpactBps?: number;
   sweepTo?: SweepTo;
   simulationPolicy?: SimulationPolicy;
@@ -103,15 +111,18 @@ export const buildRun = (run: {
   ...(run.preconditions?.length && { preconditions: run.preconditions }),
   signer: run.signer,
   ...(run.assumptions && { assumptions: run.assumptions }),
-  ...(run.referrer != null && { referrer: run.referrer }),
-  ...(run.maxPriceImpactBps != null && {
+  ...(run.referrer !== undefined && { referrer: run.referrer }),
+  ...(run.integratorFeeBps !== undefined && {
+    integratorFeeBps: run.integratorFeeBps,
+  }),
+  ...(run.maxPriceImpactBps !== undefined && {
     maxPriceImpactBps: run.maxPriceImpactBps,
   }),
-  ...(run.sweepTo != null && { sweepTo: run.sweepTo }),
-  ...(run.simulationPolicy != null && {
+  ...(run.sweepTo !== undefined && { sweepTo: run.sweepTo }),
+  ...(run.simulationPolicy !== undefined && {
     simulationPolicy: run.simulationPolicy,
   }),
-  ...(run.checkOnChainAllowances != null && {
+  ...(run.checkOnChainAllowances !== undefined && {
     checkOnChainAllowances: run.checkOnChainAllowances,
   }),
 });

package/src/sdk.ts

@@ -144,6 +144,7 @@ export const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {
       signer: run.signer,
       assumptions: run.assumptions as Record<string, bigint> | undefined,
       referrer: run.referrer,
+      integratorFeeBps: run.integratorFeeBps,
       maxPriceImpactBps: run.maxPriceImpactBps,
       sweepTo: run.sweepTo,
       simulationPolicy: run.simulationPolicy,

package/dist/guards.generated-DKKDKREA.d.ts

@@ -1,14 +0,0 @@
-import { TypedGuard } from './types.js';
-import { SlippageGuardConfig } from './generated/config.generated.js';
-
-/** Assert that output amounts are within a slippage tolerance in basis points */
-declare const slippage: <P extends string>(config: Omit<SlippageGuardConfig, "port"> & {
-    port: P;
-}) => TypedGuard<P>;
-
-declare const guardsMod_slippage: typeof slippage;
-declare namespace guardsMod {
-  export { guardsMod_slippage as slippage };
-}
-
-export { guardsMod as g, slippage as s };

package/dist/guards.generated-hrQ1KPNv.d.cts

@@ -1,14 +0,0 @@
-import { TypedGuard } from './types.cjs';
-import { SlippageGuardConfig } from './generated/config.generated.cjs';
-
-/** Assert that output amounts are within a slippage tolerance in basis points */
-declare const slippage: <P extends string>(config: Omit<SlippageGuardConfig, "port"> & {
-    port: P;
-}) => TypedGuard<P>;
-
-declare const guardsMod_slippage: typeof slippage;
-declare namespace guardsMod {
-  export { guardsMod_slippage as slippage };
-}
-
-export { guardsMod as g, slippage as s };

package/dist/materialisers.generated-BsA1uDW8.d.ts

@@ -1,24 +0,0 @@
-import { MaterialiserConfigOf, MaterialiserInput } from '@lifi/compose-spec';
-import { BalanceOfMaterialiserConfig, CallMaterialiserConfig, DirectDepositMaterialiserConfig } from './generated/config.generated.js';
-
-type BalanceOfMaterialiserInput = MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
-/** Read the on-chain token balance of an address as the input amount — accepts: resource */
-declare const balanceOf: (config: BalanceOfMaterialiserInput) => MaterialiserInput;
-type DirectDepositMaterialiserInput = MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
-/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
-declare const directDeposit: (config: DirectDepositMaterialiserInput) => MaterialiserInput;
-type CallMaterialiserInput = MaterialiserConfigOf<CallMaterialiserConfig>;
-/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
-declare const call: (config: CallMaterialiserInput) => MaterialiserInput;
-
-type materialisersMod_BalanceOfMaterialiserInput = BalanceOfMaterialiserInput;
-type materialisersMod_CallMaterialiserInput = CallMaterialiserInput;
-type materialisersMod_DirectDepositMaterialiserInput = DirectDepositMaterialiserInput;
-declare const materialisersMod_balanceOf: typeof balanceOf;
-declare const materialisersMod_call: typeof call;
-declare const materialisersMod_directDeposit: typeof directDeposit;
-declare namespace materialisersMod {
-  export { type materialisersMod_BalanceOfMaterialiserInput as BalanceOfMaterialiserInput, type materialisersMod_CallMaterialiserInput as CallMaterialiserInput, type materialisersMod_DirectDepositMaterialiserInput as DirectDepositMaterialiserInput, materialisersMod_balanceOf as balanceOf, materialisersMod_call as call, materialisersMod_directDeposit as directDeposit };
-}
-
-export { type BalanceOfMaterialiserInput as B, type CallMaterialiserInput as C, type DirectDepositMaterialiserInput as D, balanceOf as b, call as c, directDeposit as d, materialisersMod as m };

package/dist/materialisers.generated-nMxTAaVi.d.cts

@@ -1,24 +0,0 @@
-import { MaterialiserConfigOf, MaterialiserInput } from '@lifi/compose-spec';
-import { BalanceOfMaterialiserConfig, CallMaterialiserConfig, DirectDepositMaterialiserConfig } from './generated/config.generated.cjs';
-
-type BalanceOfMaterialiserInput = MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
-/** Read the on-chain token balance of an address as the input amount — accepts: resource */
-declare const balanceOf: (config: BalanceOfMaterialiserInput) => MaterialiserInput;
-type DirectDepositMaterialiserInput = MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
-/** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
-declare const directDeposit: (config: DirectDepositMaterialiserInput) => MaterialiserInput;
-type CallMaterialiserInput = MaterialiserConfigOf<CallMaterialiserConfig>;
-/** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
-declare const call: (config: CallMaterialiserInput) => MaterialiserInput;
-
-type materialisersMod_BalanceOfMaterialiserInput = BalanceOfMaterialiserInput;
-type materialisersMod_CallMaterialiserInput = CallMaterialiserInput;
-type materialisersMod_DirectDepositMaterialiserInput = DirectDepositMaterialiserInput;
-declare const materialisersMod_balanceOf: typeof balanceOf;
-declare const materialisersMod_call: typeof call;
-declare const materialisersMod_directDeposit: typeof directDeposit;
-declare namespace materialisersMod {
-  export { type materialisersMod_BalanceOfMaterialiserInput as BalanceOfMaterialiserInput, type materialisersMod_CallMaterialiserInput as CallMaterialiserInput, type materialisersMod_DirectDepositMaterialiserInput as DirectDepositMaterialiserInput, materialisersMod_balanceOf as balanceOf, materialisersMod_call as call, materialisersMod_directDeposit as directDeposit };
-}
-
-export { type BalanceOfMaterialiserInput as B, type CallMaterialiserInput as C, type DirectDepositMaterialiserInput as D, balanceOf as b, call as c, directDeposit as d, materialisersMod as m };