Position Managers

Learn how position managers automate and delegate position management with user control.

Position managers are smart contracts users can authorize to manage their positions, enabling automated actions like supplying, withdrawing, borrowing, and repaying — while maintaining full user control. They unlock use cases such as:

Each position manager is identified by its contract address and may include optional off-chain metadata, such as a name, for easier discovery.

Since registration requires governance approval, custom contracts cannot register themselves as position managers. Instead, Aave v4 ships with built-in position managers that collectively expose every operation a position manager can perform. They come in two groups: gateways and delegation managers.

Both contracts are automatically registered on every new spoke, and their addresses are available for convenience in the spoke's chain field:

interface Spoke {  __typename: "Spoke";  name: string;  address: EvmAddress;  chain: {    __typename: "Chain";    // …    nativeGateway: EvmAddress;    signatureGateway: EvmAddress;  };}

AaveKit automatically handles user authorization of these built-in position managers as part of each operation.

For example, when a user supplies native tokens (e.g., ETH):

This process happens automatically for other operations like borrowing, withdrawing, or repaying with native tokens, as well as when using ERC-20 permits to supply or repay. The SDK manages these flows transparently — users never need to interact with position managers directly.

Three additional managers let external contracts — vaults, automation bots, or your own flash loan contract — execute position operations on behalf of users without registering as position managers themselves:

To integrate a custom contract, route position operations through these managers instead of calling the spoke directly:

For example, a flash loan contract opening a leveraged position for a user:

import { IERC20 } from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";import { IGiverPositionManager } from "aave-v4/src/position-manager/interfaces/IGiverPositionManager.sol";import { ITakerPositionManager } from "aave-v4/src/position-manager/interfaces/ITakerPositionManager.sol";
// IGiverPositionManager giver = …// ITakerPositionManager taker = …// address collateralAsset = …
// Prerequisites (signed by the user, once per spoke):// - spoke.setUserPositionManager(address(giver), true, user)// - spoke.setUserPositionManager(address(taker), true, user)// - taker.approveBorrow(spoke, debtReserveId, address(this), borrowAmount)
function openLeveragedPosition(  address spoke,  uint256 collateralReserveId,  uint256 collateralAmount,  uint256 debtReserveId,  uint256 borrowAmount,  address user) external {  // Supply collateral to the user's position, funded by this contract  IERC20(collateralAsset).approve(address(giver), collateralAmount);  giver.supplyOnBehalfOf(spoke, collateralReserveId, collateralAmount, user);
  // Borrow against it, consuming the allowance granted by the user  taker.borrowOnBehalfOf(spoke, debtReserveId, borrowAmount, user);}

The production deployments on Ethereum are:

The contracts live in aave-v4/src/position-manager, and deployed addresses are listed under AaveV4EthereumPositionManagers in the Aave Address Book.

Get all available position managers for a specific spoke.

import {  type SpokePositionManagersRequest,  useSpokePositionManagers,} from "@aave/react";
function SpokePositionManagersList({  request,}: {  request: SpokePositionManagersRequest;}) {  const { data, loading, error } = useSpokePositionManagers(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  // data: PaginatedSpokePositionManagerResult  return (    <div>      <h3>Position Managers</h3>      {data.items.map((manager) => (        <div key={manager.address}>          <h4>{manager.name}</h4>          <p>Address: {manager.address}</p>          <p>Status: {manager.active ? "Active" : "Inactive"}</p>        </div>      ))}    </div>  );}

const { data, loading, error } = useSpokePositionManagers({  spoke: spoke.id,});

Get all position managers that a specific user has enabled within a spoke.

import {  type EvmAddress,  type SpokeId,  useSpokeUserPositionManagers,} from "@aave/react";
function UserPositionManagersList({  spoke,  user,}: {  spoke: SpokeId;  user: EvmAddress;}) {  const { data, loading, error } = useSpokeUserPositionManagers({    spoke,    user,  });
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  // data: PaginatedSpokeUserPositionManagerResult  return (    <div>      <h3>User Position Managers</h3>      {data.items.map((manager) => (        <div key={manager.address}>          <h4>{manager.name}</h4>          <p>Address: {manager.address}</p>          <p>Approved: {manager.approvedOn.toLocaleDateString()}</p>          <p>Status: {manager.active ? "Approved" : "Not Approved"}</p>        </div>      ))}    </div>  );}

Authorize or revoke a position manager to act on behalf of a user within a spoke.

import { useWalletClient } from "wagmi";import { useSendTransaction } from "@aave/react/viem";
// …
const { data: wallet } = useWalletClient();const [sendTransaction] = useSendTransaction(wallet);

import { useSetSpokeUserPositionManager } from "@aave/react";
const [setPositionManager, { loading, error }] = useSetSpokeUserPositionManager(  (transaction) => sendTransaction(transaction),);

import { type EvmAddress, type SpokeId } from "@aave/react";
const execute = async (  spoke: SpokeId,  manager: EvmAddress,  user: EvmAddress,) => {  const result = await setPositionManager({    spoke,    manager,    approve: true, // true to enable, false to disable    user,  });};
// …

const execute = async (/* … */) => {  const result = await setPositionManager(/* … */);
  if (result.isErr()) {    switch (result.error.name) {      case "CancelError":        // The user cancelled the operation        return;
      case "SigningError":        console.error(          `Failed to sign the transaction: ${result.error.message}`,        );        break;
      case "TimeoutError":        console.error(`Transaction timed out: ${result.error.message}`);        break;
      case "TransactionError":        console.error(`Transaction failed: ${result.error.message}`);        break;
      case "UnexpectedError":        console.error(result.error.message);        break;    }    return;  }
  console.log("Position manager enabled with hash:", result.value.txHash);};