@lifi/composer-sdk 0.0.1-alpha → 0.1.0

package/src/generated/materialisers.generated.ts

@@ -7,38 +7,38 @@ import type {
 } from '@lifi/compose-spec';
 
 import type {
-  BalanceOfMaterialiserConfig,
-  CallMaterialiserConfig,
-  DirectDepositMaterialiserConfig,
+  BalanceOfMaterialiserConfig as BalanceOfMaterialiserConfigSchema,
+  CallMaterialiserConfig as CallMaterialiserConfigSchema,
+  DirectDepositMaterialiserConfig as DirectDepositMaterialiserConfigSchema,
 } from './config.generated.js';
 
-export type BalanceOfMaterialiserInput =
-  MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
+export type BalanceOfMaterialiserConfig =
+  MaterialiserConfigOf<BalanceOfMaterialiserConfigSchema>;
 
 /** Read the on-chain token balance of an address as the input amount — accepts: resource */
 export const balanceOf = (
-  config: BalanceOfMaterialiserInput,
+  config: BalanceOfMaterialiserConfig,
 ): MaterialiserInput => ({
   kind: 'balanceOf',
   ...config,
 });
 
-export type DirectDepositMaterialiserInput =
-  MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
+export type DirectDepositMaterialiserConfig =
+  MaterialiserConfigOf<DirectDepositMaterialiserConfigSchema>;
 
 /** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
 export const directDeposit = (
-  config: DirectDepositMaterialiserInput,
+  config: DirectDepositMaterialiserConfig,
 ): MaterialiserInput => ({
   kind: 'directDeposit',
   ...config,
 });
 
-export type CallMaterialiserInput =
-  MaterialiserConfigOf<CallMaterialiserConfig>;
+export type CallMaterialiserConfig =
+  MaterialiserConfigOf<CallMaterialiserConfigSchema>;
 
 /** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
-export const call = (config: CallMaterialiserInput): MaterialiserInput => ({
+export const call = (config: CallMaterialiserConfig): MaterialiserInput => ({
   kind: 'call',
   ...config,
 });

package/src/generated/operations.generated.ts

@@ -18,19 +18,33 @@ import {
 import type { TypedGuard } from '../types.js';
 
 import type {
+  AaveBorrowConfig,
+  AaveClaimRewardsConfig,
+  AaveRepayConfig,
+  AaveRepayWithATokensConfig,
+  AaveSetEModeConfig,
   CoreApproveConfig,
   CoreAsResourceConfig,
   CoreBalanceOfConfig,
   CoreBpsDownConfig,
   CoreBpsUpConfig,
   CoreCallConfig,
+  CoreEmitEvent1Config,
+  CoreEmitEvent2Config,
+  CoreEmitEvent3Config,
+  CoreEmitEvent4Config,
   CorePeekConfig,
   CoreRawCallConfig,
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
+  InvariantNumericConfig,
+  InvariantNumericInRangeConfig,
   LifiSwapConfig,
   LifiZapConfig,
+  MorphoBlueSupplyCollateralConfig,
+  MorphoBlueWithdrawCollateralConfig,
+  ParaswapBuyConfig,
 } from './config.generated.js';
 
 /** Split a resource into two outputs by basis-point ratio */
@@ -69,13 +83,91 @@ export interface InvariantBalanceAtLeastArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
-/** Route tokens into a DeFi protocol position via the edge catalog */
-export interface LifiZapArgs {
+/** Assert that an account holds exactly an expected token balance */
+export interface InvariantBalanceEqualsArgs {
   readonly bind: {
-    readonly amountIn: Bindable<'resource'>;
+    readonly expectedAmount: Bindable<'resource'>;
+    readonly account: Bindable<'address'>;
   };
-  readonly config: LifiZapConfig;
-  readonly guards?: readonly TypedGuard<'amountOut'>[];
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that an account holds at most a maximum token balance */
+export interface InvariantBalanceAtMostArgs {
+  readonly bind: {
+    readonly maximumAmount: Bindable<'resource'>;
+    readonly account: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that an account's token balance is between a minimum and a maximum (inclusive) */
+export interface InvariantBalanceInRangeArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly maximumAmount: Bindable<'uint256'>;
+    readonly account: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner */
+export interface InvariantAllowanceAtLeastArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount */
+export interface InvariantAllowanceEqualsArgs {
+  readonly bind: {
+    readonly expectedAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner */
+export interface InvariantAllowanceAtMostArgs {
+  readonly bind: {
+    readonly maximumAmount: Bindable<'resource'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) */
+export interface InvariantAllowanceInRangeArgs {
+  readonly bind: {
+    readonly minimumAmount: Bindable<'resource'>;
+    readonly maximumAmount: Bindable<'uint256'>;
+    readonly owner: Bindable<'address'>;
+    readonly spender: Bindable<'address'>;
+  };
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation */
+export interface InvariantNumericArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNumericConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert min <= value <= max against constant bounds; reverts if outside the range */
+export interface InvariantNumericInRangeArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNumericInRangeConfig;
+  readonly guards?: readonly TypedGuard<never>[];
 }
 
 /** Add two unsigned integers (a + b) */
@@ -231,6 +323,48 @@ export interface CoreTransferArgs {
   readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];
 }
 
+/** 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). */
+export interface CoreEmitEvent1Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent1Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent2Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent2Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent3Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+    readonly value2: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent3Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */
+export interface CoreEmitEvent4Args {
+  readonly bind: {
+    readonly value0: Bindable<'bytes32'>;
+    readonly value1: Bindable<'bytes32'>;
+    readonly value2: Bindable<'bytes32'>;
+    readonly value3: Bindable<'bytes32'>;
+  };
+  readonly config: CoreEmitEvent4Config;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Invoke a smart contract function, optionally spending a token resource */
 export interface CoreCallArgs<TSig extends string = string> {
   readonly resource?: Bindable<'resource'>;
@@ -266,6 +400,80 @@ 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>[];
+}
+
+/** 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'>[];
+}
+
+/** 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 +495,6 @@ export interface LifiSwapOutputs {
   readonly unspentIn: OutputHandle<'resource'>;
 }
 
-export interface LifiZapOutputs {
-  readonly amountOut: OutputHandle<'resource'>;
-}
-
 export interface CoreAddOutputs {
   readonly result: OutputHandle<'uint256'>;
 }
@@ -336,6 +540,40 @@ 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 MorphoBlueWithdrawCollateralOutputs {
+  readonly withdrawn: OutputHandle<'resource'>;
+  readonly collateralWithdrawn: OutputHandle<'uint256'>;
+}
+
+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'>;
 }
@@ -407,6 +645,14 @@ export type GeneratedOps = {
       nodeId: string,
       args: CoreTransferArgs,
     ) => CoreTransferOutputs;
+    /** 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). — original id: "core.emitEvent1" */
+    readonly emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) => void;
+    /** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent2" */
+    readonly emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) => void;
+    /** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent3" */
+    readonly emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) => void;
+    /** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: "core.emitEvent4" */
+    readonly emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) => void;
     /** Invoke a smart contract function, optionally spending a token resource — original id: "core.call" */
     readonly call: <TSig extends string>(
       nodeId: string,
@@ -442,6 +688,85 @@ export type GeneratedOps = {
       nodeId: string,
       args: InvariantBalanceAtLeastArgs,
     ) => void;
+    /** Assert that an account holds exactly an expected token balance — original id: "invariant.balanceEquals" */
+    readonly balanceEquals: (
+      nodeId: string,
+      args: InvariantBalanceEqualsArgs,
+    ) => void;
+    /** Assert that an account holds at most a maximum token balance — original id: "invariant.balanceAtMost" */
+    readonly balanceAtMost: (
+      nodeId: string,
+      args: InvariantBalanceAtMostArgs,
+    ) => void;
+    /** Assert that an account's token balance is between a minimum and a maximum (inclusive) — original id: "invariant.balanceInRange" */
+    readonly balanceInRange: (
+      nodeId: string,
+      args: InvariantBalanceInRangeArgs,
+    ) => void;
+    /** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner — original id: "invariant.allowanceAtLeast" */
+    readonly allowanceAtLeast: (
+      nodeId: string,
+      args: InvariantAllowanceAtLeastArgs,
+    ) => void;
+    /** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount — original id: "invariant.allowanceEquals" */
+    readonly allowanceEquals: (
+      nodeId: string,
+      args: InvariantAllowanceEqualsArgs,
+    ) => void;
+    /** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner — original id: "invariant.allowanceAtMost" */
+    readonly allowanceAtMost: (
+      nodeId: string,
+      args: InvariantAllowanceAtMostArgs,
+    ) => void;
+    /** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) — original id: "invariant.allowanceInRange" */
+    readonly allowanceInRange: (
+      nodeId: string,
+      args: InvariantAllowanceInRangeArgs,
+    ) => void;
+    /** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation — original id: "invariant.numeric" */
+    readonly numeric: (nodeId: string, args: InvariantNumericArgs) => void;
+    /** Assert min <= value <= max against constant bounds; reverts if outside the range — original id: "invariant.numericInRange" */
+    readonly numericInRange: (
+      nodeId: string,
+      args: InvariantNumericInRangeArgs,
+    ) => 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;
+  };
+  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;
+  };
+  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;
   };
 };
 
@@ -509,6 +834,14 @@ export const bindGeneratedOps = (
         transferred: 'resource',
         remainder: 'resource',
       } as const),
+    emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) =>
+      builder.call(nodeId, 'core.emitEvent1', args, {}),
+    emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) =>
+      builder.call(nodeId, 'core.emitEvent2', args, {}),
+    emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) =>
+      builder.call(nodeId, 'core.emitEvent3', args, {}),
+    emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) =>
+      builder.call(nodeId, 'core.emitEvent4', args, {}),
     call: <TSig extends string>(nodeId: string, args: CoreCallArgs<TSig>) => {
       const wire = buildCallWireFormat({
         resource: args.resource,
@@ -564,5 +897,101 @@ export const bindGeneratedOps = (
         { ...args, config: {} },
         {},
       ),
+    balanceEquals: (nodeId: string, args: InvariantBalanceEqualsArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceEquals',
+        { ...args, config: {} },
+        {},
+      ),
+    balanceAtMost: (nodeId: string, args: InvariantBalanceAtMostArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceAtMost',
+        { ...args, config: {} },
+        {},
+      ),
+    balanceInRange: (nodeId: string, args: InvariantBalanceInRangeArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.balanceInRange',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceAtLeast: (nodeId: string, args: InvariantAllowanceAtLeastArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceAtLeast',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceEquals: (nodeId: string, args: InvariantAllowanceEqualsArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceEquals',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceAtMost: (nodeId: string, args: InvariantAllowanceAtMostArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceAtMost',
+        { ...args, config: {} },
+        {},
+      ),
+    allowanceInRange: (nodeId: string, args: InvariantAllowanceInRangeArgs) =>
+      builder.call(
+        nodeId,
+        'invariant.allowanceInRange',
+        { ...args, config: {} },
+        {},
+      ),
+    numeric: (nodeId: string, args: InvariantNumericArgs) =>
+      builder.call(nodeId, 'invariant.numeric', args, {}),
+    numericInRange: (nodeId: string, args: InvariantNumericInRangeArgs) =>
+      builder.call(nodeId, 'invariant.numericInRange', args, {}),
+  },
+  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, {}),
+  },
+  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),
+  },
+  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 };