fix: makes the position managers spoke-agnostic (#872)

Author: Kogaroshi

snapshots/NativeTokenGateway.Operations.json

@@ -0,0 +1,8 @@
+{
+  "borrowNative": "226558",
+  "repayNative": "241518",
+  "supplyAsCollateralNative": "155867",
+  "supplyNative": "132174",
+  "withdrawNative: full": "130004",
+  "withdrawNative: partial": "142305"
+}

snapshots/SignatureGateway.Operations.json

@@ -0,0 +1,10 @@
+{
+  "borrowWithSig": "214862",
+  "repayWithSig": "242717",
+  "setSelfAsUserPositionManagerWithSig": "92890",
+  "setUsingAsCollateralWithSig": "58839",
+  "supplyWithSig": "148895",
+  "updateUserDynamicConfigWithSig": "63202",
+  "updateUserRiskPremiumWithSig": "61971",
+  "withdrawWithSig": "136110"
+}

src/position-manager/GatewayBase.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity 0.8.28;
+
+import {Ownable2Step, Ownable} from 'src/dependencies/openzeppelin/Ownable2Step.sol';
+import {Rescuable} from 'src/utils/Rescuable.sol';
+import {ISpoke} from 'src/spoke/interfaces/ISpoke.sol';
+import {IGatewayBase} from 'src/position-manager/interfaces/IGatewayBase.sol';
+
+/// @title GatewayBase
+/// @author Aave Labs
+/// @notice Base implementation for gateway common functionalities.
+abstract contract GatewayBase is IGatewayBase, Rescuable, Ownable2Step {
+  mapping(address => bool) internal _registeredSpokes;
+
+  /// @notice Modifier that checks if the specified spoke is registered.
+  modifier onlyRegisteredSpoke(address spoke) {
+    _isSpokeValid(spoke);
+    _;
+  }
+
+  /// @dev Constructor.
+  /// @param initialOwner_ The address of the initial owner.
+  constructor(address initialOwner_) Ownable(initialOwner_) {}
+
+  /// @inheritdoc IGatewayBase
+  function registerSpoke(address spoke, bool active) external onlyOwner {
+    require(spoke != address(0), InvalidAddress());
+    _registeredSpokes[spoke] = active;
+    emit SpokeRegistered(spoke, active);
+  }
+
+  /// @inheritdoc IGatewayBase
+  function renouncePositionManagerRole(address spoke, address user) external onlyOwner {
+    require(user != address(0), InvalidAddress());
+    ISpoke(spoke).renouncePositionManagerRole(user);
+  }
+
+  /// @inheritdoc IGatewayBase
+  function isSpokeRegistered(address spoke) external view returns (bool) {
+    return _registeredSpokes[spoke];
+  }
+
+  /// @dev Verifies the specified spoke is registered.
+  function _isSpokeValid(address spoke) internal view {
+    require(_registeredSpokes[spoke], SpokeNotRegistered());
+  }
+
+  /// @return The underlying asset for `reserveId` on the specified spoke.
+  /// @return The corresponding hub address.
+  function _getReserveData(
+    address spoke,
+    uint256 reserveId
+  ) internal view returns (address, address) {
+    ISpoke.Reserve memory reserveData = ISpoke(spoke).getReserve(reserveId);
+    return (reserveData.underlying, address(reserveData.hub));
+  }
+
+  /// @dev The `owner()` is the allowed caller for Rescuable methods.
+  function _rescueGuardian() internal view override returns (address) {
+    return owner();
+  }
+}

src/position-manager/NativeTokenGateway.sol

@@ -3,42 +3,29 @@
 pragma solidity 0.8.28;
 
 import {ReentrancyGuardTransient} from 'src/dependencies/openzeppelin/ReentrancyGuardTransient.sol';
-import {Ownable2Step, Ownable} from 'src/dependencies/openzeppelin/Ownable2Step.sol';
 import {SafeERC20, IERC20} from 'src/dependencies/openzeppelin/SafeERC20.sol';
 import {Address} from 'src/dependencies/openzeppelin/Address.sol';
 import {MathUtils} from 'src/libraries/math/MathUtils.sol';
-import {Rescuable} from 'src/utils/Rescuable.sol';
 import {ISpoke} from 'src/spoke/interfaces/ISpoke.sol';
 import {INativeWrapper} from 'src/position-manager/interfaces/INativeWrapper.sol';
+import {GatewayBase} from 'src/position-manager/GatewayBase.sol';
 import {INativeTokenGateway} from 'src/position-manager/interfaces/INativeTokenGateway.sol';
 
 /// @title NativeTokenGateway
 /// @author Aave Labs
 /// @notice Gateway to interact with a spoke using the native coin of a chain.
 /// @dev Contract must be an active & approved user position manager in order to execute spoke actions on a user's behalf.
-contract NativeTokenGateway is
-  INativeTokenGateway,
-  ReentrancyGuardTransient,
-  Rescuable,
-  Ownable2Step
-{
+contract NativeTokenGateway is INativeTokenGateway, GatewayBase, ReentrancyGuardTransient {
   using SafeERC20 for *;
 
   INativeWrapper internal immutable _nativeWrapper;
-  ISpoke internal immutable _spoke;
 
   /// @dev Constructor.
   /// @param nativeWrapper_ The address of the native wrapper contract.
-  /// @param spoke_ The address of the connected spoke.
   /// @param initialOwner_ The address of the initial owner.
-  constructor(
-    address nativeWrapper_,
-    address spoke_,
-    address initialOwner_
-  ) Ownable(initialOwner_) {
-    require(nativeWrapper_ != address(0) && spoke_ != address(0), InvalidAddress());
+  constructor(address nativeWrapper_, address initialOwner_) GatewayBase(initialOwner_) {
+    require(nativeWrapper_ != address(0), InvalidAddress());
     _nativeWrapper = INativeWrapper(payable(nativeWrapper_));
-    _spoke = ISpoke(spoke_);
   }
 
   /// @dev Checks only 'nativeWrapper' can transfer native tokens.
@@ -52,95 +39,103 @@ contract NativeTokenGateway is
   }
 
   /// @inheritdoc INativeTokenGateway
-  function supplyNative(uint256 reserveId, uint256 amount) external payable nonReentrant {
-    (IERC20 underlying, address hub) = _getReserveData(reserveId);
-    _validateParams(underlying, amount);
+  function supplyNative(
+    address spoke,
+    uint256 reserveId,
+    uint256 amount
+  ) external payable nonReentrant onlyRegisteredSpoke(spoke) {
     require(msg.value == amount, NativeAmountMismatch());
+    _supplyNative(spoke, reserveId, msg.sender, amount);
+  }
 
-    _nativeWrapper.deposit{value: amount}();
-    _nativeWrapper.forceApprove(hub, amount);
-    _spoke.supply(reserveId, amount, msg.sender);
+  /// @inheritdoc INativeTokenGateway
+  function supplyAsCollateralNative(
+    address spoke,
+    uint256 reserveId,
+    uint256 amount
+  ) external payable nonReentrant onlyRegisteredSpoke(spoke) {
+    require(msg.value == amount, NativeAmountMismatch());
+    _supplyNative(spoke, reserveId, msg.sender, amount);
+    ISpoke(spoke).setUsingAsCollateral(reserveId, true, msg.sender);
   }
 
   /// @inheritdoc INativeTokenGateway
-  function withdrawNative(uint256 reserveId, uint256 amount, address receiver) external {
-    (IERC20 underlying, ) = _getReserveData(reserveId);
+  function withdrawNative(
+    address spoke,
+    uint256 reserveId,
+    uint256 amount
+  ) external onlyRegisteredSpoke(spoke) {
+    (address underlying, ) = _getReserveData(spoke, reserveId);
     _validateParams(underlying, amount);
-    require(receiver != address(0), InvalidAddress());
 
     uint256 withdrawAmount = MathUtils.min(
       amount,
-      _spoke.getUserSuppliedAssets(reserveId, msg.sender)
+      ISpoke(spoke).getUserSuppliedAssets(reserveId, msg.sender)
     );
 
-    _spoke.withdraw(reserveId, withdrawAmount, msg.sender);
+    ISpoke(spoke).withdraw(reserveId, withdrawAmount, msg.sender);
     _nativeWrapper.withdraw(withdrawAmount);
-    Address.sendValue(payable(receiver), withdrawAmount);
+    Address.sendValue(payable(msg.sender), withdrawAmount);
   }
 
   /// @inheritdoc INativeTokenGateway
-  function borrowNative(uint256 reserveId, uint256 amount, address receiver) external {
-    (IERC20 underlying, ) = _getReserveData(reserveId);
+  function borrowNative(
+    address spoke,
+    uint256 reserveId,
+    uint256 amount
+  ) external onlyRegisteredSpoke(spoke) {
+    (address underlying, ) = _getReserveData(spoke, reserveId);
     _validateParams(underlying, amount);
-    require(receiver != address(0), InvalidAddress());
 
-    _spoke.borrow(reserveId, amount, msg.sender);
+    ISpoke(spoke).borrow(reserveId, amount, msg.sender);
     _nativeWrapper.withdraw(amount);
-    Address.sendValue(payable(receiver), amount);
+    Address.sendValue(payable(msg.sender), amount);
   }
 
   /// @inheritdoc INativeTokenGateway
-  function repayNative(uint256 reserveId, uint256 amount) external payable nonReentrant {
-    (IERC20 underlying, address hub) = _getReserveData(reserveId);
-    _validateParams(underlying, amount);
+  function repayNative(
+    address spoke,
+    uint256 reserveId,
+    uint256 amount
+  ) external payable nonReentrant onlyRegisteredSpoke(spoke) {
     require(msg.value == amount, NativeAmountMismatch());
+    (address underlying, address hub) = _getReserveData(spoke, reserveId);
+    _validateParams(underlying, amount);
 
-    uint256 userDebtAmount = _spoke.getUserTotalDebt(reserveId, msg.sender);
+    uint256 userTotalDebt = ISpoke(spoke).getUserTotalDebt(reserveId, msg.sender);
     uint256 repayAmount = amount;
     uint256 leftovers;
-    if (amount > userDebtAmount) {
-      leftovers = amount - userDebtAmount;
-      repayAmount = userDebtAmount;
+    if (amount > userTotalDebt) {
+      leftovers = amount - userTotalDebt;
+      repayAmount = userTotalDebt;
     }
 
     _nativeWrapper.deposit{value: repayAmount}();
     _nativeWrapper.forceApprove(hub, repayAmount);
-    _spoke.repay(reserveId, repayAmount, msg.sender);
+    ISpoke(spoke).repay(reserveId, repayAmount, msg.sender);
 
     if (leftovers > 0) {
       Address.sendValue(payable(msg.sender), leftovers);
     }
   }
 
-  /// @inheritdoc INativeTokenGateway
-  function renouncePositionManagerRole(address user) external onlyOwner {
-    _spoke.renouncePositionManagerRole(user);
-  }
-
   /// @inheritdoc INativeTokenGateway
   function NATIVE_WRAPPER() external view returns (address) {
     return address(_nativeWrapper);
   }
 
-  /// @inheritdoc INativeTokenGateway
-  function SPOKE() external view returns (address) {
-    return address(_spoke);
-  }
+  /// @dev `msg.value` verification must be done before calling this.
+  function _supplyNative(address spoke, uint256 reserveId, address user, uint256 amount) internal {
+    (address underlying, address hub) = _getReserveData(spoke, reserveId);
+    _validateParams(underlying, amount);
 
-  /// @dev RescueGuardian is the owner of the contract.
-  function _rescueGuardian() internal view override returns (address) {
-    return owner();
+    _nativeWrapper.deposit{value: amount}();
+    _nativeWrapper.forceApprove(hub, amount);
+    ISpoke(spoke).supply(reserveId, amount, user);
   }
 
-  function _validateParams(IERC20 underlying, uint256 amount) internal view {
-    require(address(underlying) == address(_nativeWrapper), NotNativeWrappedAsset());
+  function _validateParams(address underlying, uint256 amount) internal view {
+    require(address(_nativeWrapper) == underlying, NotNativeWrappedAsset());
     require(amount > 0, InvalidAmount());
   }
-
-  /// @return The underlying asset for `reserveId` on connected spoke.
-  /// @return The corresponding hub address.
-  function _getReserveData(uint256 reserveId) internal view returns (IERC20, address) {
-    ISpoke.Reserve memory reserveData = _spoke.getReserve(reserveId);
-    return (IERC20(reserveData.underlying), address(reserveData.hub));
-  }
 }