Skip to main content

Simulate a base lending operation on-chain

GET 

/v1/actions/lending/simulate

Build a base lending operation and execute it against live chain state before the user signs it.

This is an EVM check, not the arithmetic projection that simulate=true adds to the other lending endpoints. The transaction is built by the very endpoint the client would call (/v1/actions/lending/{action}) and then replayed through an eth_call with storage overrides — so what is verified is the exact calldata that would be submitted, including the lender quirks that only surface on-chain.

Scope is the four single-grant operations. deposit and repay override the pay token (funding balance and approval in one write); withdraw and borrow override the lender's own grant mapping (Aave credit delegation, Morpho isAuthorized, Comet isAllowed) so the action can be previewed before the user has signed that permission. Anything needing two grants at once — notably a leverage open that pulls fresh margin and borrows on behalf — cannot be previewed cold and is out of scope.

The override is optimistic. willSucceed: true with grantOverridden: true means "this succeeds once the permission exists"; it is not evidence the permission exists. Keep gating the real grant on the permissions array.

The simulation object is either:

  • { simulated: true, willSucceed, gasUsed, amountOut, returnData, revertReason?, block, grantOverridden }
  • { simulated: false, reason, detail } — where reason is one of NO_TRANSACTION, MULTI_STEP, NATIVE_VALUE, MULTIPLE_GRANTS, GRANT_SLOT_UNKNOWN, SIMULATOR_UNAVAILABLE.

Note amountOut is a measured balance delta on operator, so it reads 0 for lenders with no receipt token (Morpho Blue and every CDP-shaped lender) — those return their own values in returnData instead. A simulator outage never fails the request: the calldata is still returned and remains valid.

Plain-text reference — GET /v1/actions/lending/simulate

Parameters

ParameterInTypeRequiredDescription
actionquerystringyesWhich base operation to build and replay: deposit, withdraw, borrow or repay.
marketUidquerystringyesMarket identifier (lender:chainId:address). The address encodes the underlying token (Aave/Morpho/CompoundV3), cToken (CompoundV2), or pool (Init Capital).
amountquerystringyesAmount in wei
modequeryproxy, directnoExecution mode. Omit it (recommended) and the API picks the path per request: direct (a raw protocol call) when the protocol can serve the request as given, otherwise proxy (the 1delta composer) — e.g. a custom receiver the protocol call cannot express, or a payAsset that needs wrapping. A payAsset that needs a swap routes through a DEX aggregator.

The transaction to is therefore NOT always the protocol contract: on the proxy path it is the composer, and the ERC-20 approval in actions.permissions targets the composer too. Send what the response returns.

Pass direct or proxy only to force a path; a forced path that cannot serve the request (for instance a custom receiver on a lender whose direct call has no recipient slot) is refused with 400 INVALID_PARAM, never built. | | operator | query | string | yes | Wallet address that signs and sends the transaction (and pays, for deposit/repay). Not necessarily the position owner — see receiver. | | receiver | query | string | no | Recipient of the lender position (deposit), of the underlying tokens (borrow/withdraw), or the account whose debt is repaid (repay). Defaults to operator when omitted — so an on-behalf deposit MUST pass this parameter; there is no onBehalf / onBehalfOf alias, and an unknown parameter name is ignored.

Custom-receiver support is per-lender. The API auto-selects the execution path:

Direct path supported

  • Aave V2/V3 — supply / withdraw honor to.
  • Aave V4 — deposit via GiverPM supplyOnBehalfOf. Requires the GiverPM to be curated in aave-v4-peripherals.json with a name containing "giver".
  • Compound V3 — supplyTo / withdrawTo (a borrow is a withdrawTo of the base asset).
  • Morpho Blue & Lista DAO ERC-20 markets — Morpho onBehalf (repay included).
  • Euler V2 ERC-20 vaults — ERC-4626 deposit(receiver), repay(assets, receiver). Collateral auto-enable is dropped for non-sub-account receivers.
  • Exactly — repay / repayAtMaturity take the borrower.
  • Silo V2/V3 ERC-20 — deposit(_, receiver, _).
  • Gearbox V3 passive-pool deposits — ERC-4626 deposit(_, receiver).
  • Fluid borrow & withdraw — operate(..., to_) outflow slot.
  • Fluid deposit to an existing NFT when accountId is supplied — pure-deposit operate() calls bypass Fluid's owner auth gate, and the API folds a pre-flight VaultFactory.ownerOf(nftId) == receiver check into the merged multicall (rejects with 400 INVALID_PARAM on mismatch, VALIDATION_FAILED if the RPC can't confirm ownership).

Routes to composer (proxy) path

  • Compound V2 family — direct mint is msg.sender-only.
  • Fluid fresh-open deposits — no accountId or accountId=0. The composer mints the new position NFT to itself, then transfers it to receiver via the encoder's nftReceiver slot.
  • Native-ETH vaults on Fluid (deposit / withdraw / repay) and the CompoundV2 family — the composer forwards msg.value to the vault's payable entrypoint. Other lenders' composer paths reject native asset and require wrapped-native as payAsset.

Refused with a receiver (the on-chain call has no recipient)

  • Gearbox V3 credit-side addCollateral — CA bound to operator — and Gearbox V3 borrow (the funds stay in the credit account).
  • Liquity V2 family — Stability Pool deposit / withdrawal (provideToSP / withdrawFromSP) and trove collateral withdrawal (withdrawColl pays the trove's own receiver).
  • Aave V4 native-gateway path — supplyAsCollateralNative has no recipient slot.

Unsupported in any single tx

  • Init Capital — position NFT swept to operator.
  • Euler V2 / Silo V2/V3 native deposit paths — router/orchestrator credits msg.sender.
  • Fluid repay — on-chain primitive permits it, direct handler doesn't expose a receiver slot yet (routes to proxy as a conservative default).

Repay with a receiver settles the RECEIVER's debt with the operator's funds. On Euler V2, Morpho Blue / Lista and Exactly, isAll=true with a receiver is refused: the amount owed would be read from the operator, not the receiver — pass an explicit amount.

When the lender cannot honor a custom receiver on the direct path and mode is omitted, the API routes the request through the composer automatically — the response then targets the composer (see mode). Forcing mode=direct with a custom receiver the direct call cannot express (Compound V2, Init, a Fluid fresh open) is refused with 400 INVALID_PARAM, and a leg with no recipient (above) with 400 ACTION_FAILED; a receiver is never silently replaced by the operator.

The optional simulation preview is computed for the operator, not the receiver: with a custom receiver it shows the position change on the operator's account. Read the receiver's position from the user-positions endpoint after execution. | | payAsset | query | string | no | Asset to pay with.

Use the zero address to pay with native ETH on lenders whose vault accepts native (e.g. Init Capital, Fluid native-ETH vaults, CompoundV2 cETH markets).

Proxy mode: defaults to market asset. Native is forwarded as msg.value only when the lender supports it (e.g. Fluid, CompoundV2); otherwise the composer rejects. | | isShares | query | boolean | no | Amount is in shares (direct mode) | | accountId | query | string | no | Per-position identifier. Lender-specific:

  • Init Capital — account ID, required for borrow/withdraw/repay.
  • Euler V2 — sub-account index (0..255), defaults to 0.
  • Gearbox V3 — credit-account address (alias: creditAccount).
  • Dolomite — margin account number (uint256, 0 = the default cross-margin account), or iso:<marketId>:<n> for a position inside an isolation-mode VAULT (dGM, dsavETH, dGMX …). The vault, not the user, owns that DolomiteMargin account; n must be >= 100 for a borrow position and 0 is the vault's supply-only balance. Position ids come back in this form from /v1/data/lending/positions.
  • Fluid — position NFT id. Omit or pass 0 to mint a new position; supply an existing nftId to act on an existing position. Required for borrow/withdraw/repay; for deposit it unlocks the direct path with a custom receiver (deposit lands on the receiver-owned NFT after pre-flight ownerOf validation). | | slippage | query | number | no | Slippage tolerance in basis points (50 = 0.5%, 100 = 1%).

Required whenever the action has to price something:

  • Aggregator swap — when payAsset / receiveAsset differs from the market's underlying, the currency conversion is routed through a DEX aggregator and this bounds that swap.
  • Order-book take (Morpho Midnight) — bounds the worst execution price accepted while filling offers.

Ignored when neither applies (same-asset action on a pool lender). | | simulate | query | boolean | no | When true, the API fetches the operator's on-chain balances and returns projected post-trade metrics in the simulation field. The projection is always of the operator's account: with a custom receiver it does not show the receiver's position. Default: false. | | block | query | string | no | Block number or tag to simulate against. Defaults to latest. |

Request​

Responses​

Transaction calldata plus the on-chain execution result