@lifi/composer-sdk 0.2.0-staging.4 → 0.2.0

package/src/generated/operations.generated.ts

@@ -20,7 +20,6 @@ import type { TypedGuard } from '../types.js';
 import type {
   AaveBorrowConfig,
   AaveClaimRewardsConfig,
-  AaveGetHealthFactorConfig,
   AaveRepayConfig,
   AaveRepayWithATokensConfig,
   AaveSetEModeConfig,
@@ -30,21 +29,27 @@ import type {
   CoreBpsDownConfig,
   CoreBpsUpConfig,
   CoreCallConfig,
+  CoreEmitEvent1Config,
+  CoreEmitEvent2Config,
+  CoreEmitEvent3Config,
+  CoreEmitEvent4Config,
   CorePeekConfig,
   CoreRawCallConfig,
   CoreSplitConfig,
   CoreStaticCallConfig,
   CoreTransferConfig,
-  LifiFlashloanRepayConfig,
+  InvariantEqConfig,
+  InvariantGtConfig,
+  InvariantGteConfig,
+  InvariantLtConfig,
+  InvariantLteConfig,
+  InvariantNeqConfig,
+  InvariantNumericConfig,
+  InvariantNumericInRangeConfig,
   LifiSwapConfig,
   LifiZapConfig,
-  MorphoBlueBorrowConfig,
-  MorphoBlueGetPositionConfig,
-  MorphoBlueRepayConfig,
   MorphoBlueSupplyCollateralConfig,
-  MorphoBlueSupplyConfig,
   MorphoBlueWithdrawCollateralConfig,
-  MorphoBlueWithdrawConfig,
   ParaswapBuyConfig,
 } from './config.generated.js';
 
@@ -84,6 +89,147 @@ export interface InvariantBalanceAtLeastArgs {
   readonly guards?: readonly TypedGuard<never>[];
 }
 
+/** Assert that an account holds exactly an expected token balance */
+export interface InvariantBalanceEqualsArgs {
+  readonly bind: {
+    readonly expectedAmount: Bindable<'resource'>;
+    readonly account: Bindable<'address'>;
+  };
+  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>[];
+}
+
+/** Assert a uint256 value is greater than or equal to a constant threshold; reverts on violation */
+export interface InvariantGteArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantGteConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is strictly greater than a constant threshold; reverts on violation */
+export interface InvariantGtArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantGtConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is less than or equal to a constant threshold; reverts on violation */
+export interface InvariantLteArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantLteConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value is strictly less than a constant threshold; reverts on violation */
+export interface InvariantLtArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantLtConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value equals a constant threshold; reverts on violation */
+export interface InvariantEqArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantEqConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
+/** Assert a uint256 value does not equal a constant threshold; reverts on violation */
+export interface InvariantNeqArgs {
+  readonly bind: {
+    readonly value: Bindable<'uint256'>;
+  };
+  readonly config: InvariantNeqConfig;
+  readonly guards?: readonly TypedGuard<never>[];
+}
+
 /** Add two unsigned integers (a + b) */
 export interface CoreAddArgs {
   readonly bind: {
@@ -237,6 +383,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'>;
@@ -312,13 +500,6 @@ export interface AaveSetEModeArgs {
   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: {
@@ -335,64 +516,6 @@ export interface MorphoBlueWithdrawCollateralArgs {
   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: {
@@ -497,45 +620,11 @@ export interface AaveClaimRewardsOutputs {
   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'>;
 }
@@ -616,6 +705,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,
@@ -642,11 +739,6 @@ 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;
   };
@@ -656,6 +748,60 @@ 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;
+    /** Assert a uint256 value is greater than or equal to a constant threshold; reverts on violation — original id: "invariant.gte" */
+    readonly gte: (nodeId: string, args: InvariantGteArgs) => void;
+    /** Assert a uint256 value is strictly greater than a constant threshold; reverts on violation — original id: "invariant.gt" */
+    readonly gt: (nodeId: string, args: InvariantGtArgs) => void;
+    /** Assert a uint256 value is less than or equal to a constant threshold; reverts on violation — original id: "invariant.lte" */
+    readonly lte: (nodeId: string, args: InvariantLteArgs) => void;
+    /** Assert a uint256 value is strictly less than a constant threshold; reverts on violation — original id: "invariant.lt" */
+    readonly lt: (nodeId: string, args: InvariantLtArgs) => void;
+    /** Assert a uint256 value equals a constant threshold; reverts on violation — original id: "invariant.eq" */
+    readonly eq: (nodeId: string, args: InvariantEqArgs) => void;
+    /** Assert a uint256 value does not equal a constant threshold; reverts on violation — original id: "invariant.neq" */
+    readonly neq: (nodeId: string, args: InvariantNeqArgs) => 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" */
@@ -677,11 +823,6 @@ export type GeneratedOps = {
     ) => 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" */
@@ -694,31 +835,6 @@ export type GeneratedOps = {
       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" */
@@ -790,6 +906,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,
@@ -832,8 +956,6 @@ 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',
@@ -847,6 +969,71 @@ 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, {}),
+    gte: (nodeId: string, args: InvariantGteArgs) =>
+      builder.call(nodeId, 'invariant.gte', args, {}),
+    gt: (nodeId: string, args: InvariantGtArgs) =>
+      builder.call(nodeId, 'invariant.gt', args, {}),
+    lte: (nodeId: string, args: InvariantLteArgs) =>
+      builder.call(nodeId, 'invariant.lte', args, {}),
+    lt: (nodeId: string, args: InvariantLtArgs) =>
+      builder.call(nodeId, 'invariant.lt', args, {}),
+    eq: (nodeId: string, args: InvariantEqArgs) =>
+      builder.call(nodeId, 'invariant.eq', args, {}),
+    neq: (nodeId: string, args: InvariantNeqArgs) =>
+      builder.call(nodeId, 'invariant.neq', args, {}),
   },
   aave: {
     borrow: (nodeId: string, args: AaveBorrowArgs) =>
@@ -871,10 +1058,6 @@ export const bindGeneratedOps = (
       } 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) =>
@@ -887,36 +1070,6 @@ export const bindGeneratedOps = (
         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) =>

package/src/index.ts

@@ -51,6 +51,22 @@ export type {
   SimulationRevert,
   SolType,
   SweepTo,
+  SimulateRequest,
+  SimulateResult,
+  SimulateOkResult,
+  SimulateRevertResult,
+  SimulateRevertDecodeResult,
+  SimulateSetupErrorResult,
+  SimulateBalanceEntry,
+  TrackedBalance,
+  SlotFinderRequirement,
+  Erc20BalanceRequirement,
+  NativeBalanceRequirement,
+  Erc20AllowanceRequirement,
+} from '@lifi/compose-spec';
+export {
+  SIMULATE_MAX_TRACKED_BALANCES,
+  SIMULATE_MAX_REQUIREMENTS,
 } from '@lifi/compose-spec';
 export { isComposeError } from './errors.js';
 
@@ -70,6 +86,9 @@ export type { TypedFlow, FlowOptions } from './authoring/FlowBuilderCore.js';
 export type { ComposeRunInput } from './run/inputs.js';
 export { materialiser } from './run/inputs.js';
 
+export { buildSimulateRequest } from './run/simulate.js';
+export type { BuildSimulateRequestInput } from './run/simulate.js';
+
 export { createComposeSdk } from './sdk.js';
 export type { ComposeSdk, ComposeSdkOptions, FlowBuilder } from './sdk.js';