[ETHEREUM-CONTRACTS] allow connecting pools on behalf of members (with some constraints) (#2093)

---------

Co-authored-by: Miao ZhiCheng <miao@superfluid.finance>

Author: d10r

packages/automation-contracts/autowrap/foundry.toml

@@ -3,7 +3,7 @@ root = '../../../'
 libs = ['lib']
 src = 'packages/automation-contracts/autowrap'
 solc_version = "0.8.30"
-evm_version = 'paris'
+evm_version = 'shanghai'
 optimizer = true
 optimizer_runs = 200
 remappings = [

packages/automation-contracts/scheduler/foundry.toml

@@ -3,7 +3,7 @@ root = '../../../'
 libs = ['lib']
 src = 'packages/automation-contracts/scheduler'
 solc_version = "0.8.30"
-evm_version = 'paris'
+evm_version = 'shanghai'
 optimizer = true
 optimizer_runs = 200
 remappings = [

packages/ethereum-contracts/CHANGELOG.md

@@ -5,12 +5,16 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [UNRELEASED]
 
+### Added
+- GDA _autoconnect_ feature: now any account can connect pool members using `tryConnectPoolFor()` as long as they have less than 4 connection slots occupied for that Super Token. This allows for smoother onboarding of new users, allowing Apps to make sure tokens distributed via GDA immediately show up in user's wallets. Accounts can opt out of this by using `setConnectPermission()`, this is mainly supposed to be used by contracts.
+
 ### Changed
 - Refactored `GeneralDistributionAgreementV1`: extracted functionality which reads/writes agreement data from/to the token contract into dedicated libraries:
   - `GDAv1StorageLib` contains data structures and related encoders/decoders.
   - `GDAv1StorageReader` contains getters reading agreement data from the token contract, allowing contracts to get this data without making a call to the GDA contract.
   - `GDAv1StorageWriter` contains functions for writing agreement data to the token contract. This can only be used by the GDA contract itself.
 - bump solc to "0.8.30".
+- Changed EVM target from `paris` to `shanghai` because now all networks with supported Superfluid deployment support it.
 
 ### Fixed
 - `ISuperfluidPool`: `getClaimable` and `getClaimableNow` could previously return non-zero values for connected pools, which was inconsistent with what `claimAll` would actually do in this situation (claim nothing).

packages/ethereum-contracts/contracts/agreements/gdav1/GeneralDistributionAgreementV1.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.23;
 
 import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
 
-import { ISuperfluid, ISuperfluidGovernance } from "../../interfaces/superfluid/ISuperfluid.sol";
+import { ISuperfluid, ISuperfluidGovernance, IAccessControl } from "../../interfaces/superfluid/ISuperfluid.sol";
 import {
     BasicParticle,
     PDPoolIndex,
@@ -23,8 +23,6 @@ import {
 } from "../../interfaces/agreements/gdav1/IGeneralDistributionAgreementV1.sol";
 import { SuperfluidUpgradeableBeacon } from "../../upgradability/SuperfluidUpgradeableBeacon.sol";
 import { ISuperfluidToken } from "../../interfaces/superfluid/ISuperfluidToken.sol";
-import { ISuperToken } from "../../interfaces/superfluid/ISuperToken.sol";
-import { IPoolAdminNFT } from "../../interfaces/agreements/gdav1/IPoolAdminNFT.sol";
 import { ISuperfluidPool } from "../../interfaces/agreements/gdav1/ISuperfluidPool.sol";
 import { SlotsBitmapLibrary } from "../../libs/SlotsBitmapLibrary.sol";
 import { SolvencyHelperLibrary } from "../../libs/SolvencyHelperLibrary.sol";
@@ -48,6 +46,12 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
 
     address public constant SUPERFLUID_POOL_DEPLOYER_ADDRESS = address(SuperfluidPoolDeployerLibrary);
 
+    // @dev The max number of slots which can be used for connecting pools on behalf of a member (per token)
+    uint32 public constant MAX_POOL_AUTO_CONNECT_SLOTS = 4;
+
+    // @dev The ACL role owned by this contract, used to persist autoconnect permissions for accounts
+    bytes32 constant public ACL_POOL_CONNECT_EXCLUSIVE_ROLE = keccak256("ACL_POOL_CONNECT_EXCLUSIVE_ROLE");
+
     /// @dev Pool member state slot id for storing subs bitmap
     uint256 private constant _POOL_SUBS_BITMAP_STATE_SLOT_ID = 1;
     /// @dev Pool member state slot id starting point for pool connections
@@ -228,7 +232,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
     function _createPool(
         ISuperfluidToken token,
         address admin,
-        PoolConfig memory config,
+        PoolConfig calldata config,
         PoolERC20Metadata memory poolERC20Metadata
     ) internal returns (ISuperfluidPool pool) {
         // @note ensure if token and admin are the same that nothing funky happens with echidna
@@ -245,17 +249,13 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
 
         token.setIsPoolFlag(pool);
 
-        IPoolAdminNFT poolAdminNFT = IPoolAdminNFT(_getPoolAdminNFTAddress(token));
-
-        if (address(poolAdminNFT) != address(0)) {
-            poolAdminNFT.mint(address(pool));
-        }
+        SuperfluidPoolDeployerLibrary.mintPoolAdminNFT(token, pool);
 
         emit PoolCreated(token, admin, pool);
     }
 
     /// @inheritdoc IGeneralDistributionAgreementV1
-    function createPool(ISuperfluidToken token, address admin, PoolConfig memory config)
+    function createPool(ISuperfluidToken token, address admin, PoolConfig calldata config)
         external
         override
         returns (ISuperfluidPool pool)
@@ -272,7 +272,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
     function createPoolWithCustomERC20Metadata(
         ISuperfluidToken token,
         address admin,
-        PoolConfig memory config,
+        PoolConfig calldata config,
         PoolERC20Metadata memory poolERC20Metadata
     ) external override returns (ISuperfluidPool pool) {
         return _createPool(token, admin, config, poolERC20Metadata);
@@ -305,49 +305,106 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         pool.claimAll(memberAddress);
     }
 
-    // @note setPoolConnection function naming
-    function connectPool(ISuperfluidPool pool, bool doConnect, bytes calldata ctx)
-        public
-        returns (bytes memory newCtx)
+    /// @inheritdoc IGeneralDistributionAgreementV1
+    function connectPool(ISuperfluidPool pool, bytes calldata ctx) external override returns (bytes memory newCtx) {
+        newCtx = ctx;
+        _setPoolConnectionFor(pool, address(0), true /* doConnect */, ctx);
+    }
+
+    /// @inheritdoc IGeneralDistributionAgreementV1
+    function tryConnectPoolFor(ISuperfluidPool pool, address memberAddr, bytes calldata ctx)
+        external
+        override
+        returns (bool success, bytes memory newCtx)
+    {
+        newCtx = ctx;
+
+        if (pool.superToken().isPool(this, memberAddr)) {
+            revert GDA_CANNOT_CONNECT_POOL();
+        }
+
+        // check if the member has opted out of autoconnect
+        IAccessControl simpleACL = ISuperfluid(_host).getSimpleACL();
+        if (simpleACL.hasRole(ACL_POOL_CONNECT_EXCLUSIVE_ROLE, memberAddr)) {
+            success = false;
+        } else {
+            success = _setPoolConnectionFor(pool, memberAddr, true /* doConnect */, ctx);
+        }
+    }
+
+    function setConnectPermission(bool allow) external override {
+        IAccessControl simpleACL = ISuperfluid(_host).getSimpleACL();
+        if (!allow) {
+            simpleACL.grantRole(ACL_POOL_CONNECT_EXCLUSIVE_ROLE, msg.sender);
+        } else {
+            simpleACL.revokeRole(ACL_POOL_CONNECT_EXCLUSIVE_ROLE, msg.sender);
+        }
+    }
+
+    /// @inheritdoc IGeneralDistributionAgreementV1
+    function disconnectPool(ISuperfluidPool pool, bytes calldata ctx) external override returns (bytes memory newCtx) {
+        newCtx = ctx;
+        _setPoolConnectionFor(pool, address(0), false /* doConnect */, ctx);
+    }
+
+    // @note memberAddr has override semantics - if set to address(0), it will be set to the msgSender
+    function _setPoolConnectionFor(
+        ISuperfluidPool pool,
+        address memberAddr,
+        bool doConnect,
+        bytes memory ctx
+    )
+        internal
+        returns (bool success)
     {
         ISuperfluidToken token = pool.superToken();
         ISuperfluid.Context memory currentContext = AgreementLibrary.authorizeTokenAccess(token, ctx);
-        address msgSender = currentContext.msgSender;
-        newCtx = ctx;
-        bool isConnected = token.isPoolMemberConnected(this, pool, msgSender);
-        if (doConnect != isConnected) {
-            assert(
-                SuperfluidPool(address(pool)).operatorConnectMember(
-                    msgSender, doConnect, uint32(currentContext.timestamp)
-                )
-            );
 
+        bool autoConnectForOtherMember = false;
+        if (memberAddr == address(0)) {
+            memberAddr = currentContext.msgSender;
+        } else {
+            autoConnectForOtherMember = true;
+        }
+
+        bool isConnected = token.isPoolMemberConnected(this, pool, memberAddr);
+
+        if (doConnect != isConnected) {
             if (doConnect) {
-                uint32 poolSlotId =
-                    _findAndFillPoolConnectionsBitmap(token, msgSender, bytes32(uint256(uint160(address(pool)))));
+                if (autoConnectForOtherMember) {
+                    // check if we're below the slot limit for autoconnect
+                   uint256 nUsedSlots = SlotsBitmapLibrary.countUsedSlots(
+                        token, memberAddr, _POOL_SUBS_BITMAP_STATE_SLOT_ID
+                    );
+                    if (nUsedSlots >= MAX_POOL_AUTO_CONNECT_SLOTS) {
+                        return false;
+                    }
+                }
+
+                uint32 poolSlotId = _findAndFillPoolConnectionsBitmap(
+                    token, memberAddr, bytes32(uint256(uint160(address(pool))))
+                );
 
                 token.createPoolConnectivity
-                    (msgSender, GDAv1StorageLib.PoolConnectivity({ slotId: poolSlotId, pool: pool }));
+                    (memberAddr, GDAv1StorageLib.PoolConnectivity({ slotId: poolSlotId, pool: pool }));
             } else {
                 (, GDAv1StorageLib.PoolConnectivity memory poolConnectivity) =
-                    token.getPoolConnectivity(this, msgSender, pool);
-                token.deletePoolConnectivity(msgSender, pool);
+                    token.getPoolConnectivity(this, memberAddr, pool);
+                token.deletePoolConnectivity(memberAddr, pool);
 
-                _clearPoolConnectionsBitmap(token, msgSender, poolConnectivity.slotId);
+                _clearPoolConnectionsBitmap(token, memberAddr, poolConnectivity.slotId);
             }
 
-            emit PoolConnectionUpdated(token, pool, msgSender, doConnect, currentContext.userData);
-        }
-    }
+            assert(
+                SuperfluidPool(address(pool)).operatorConnectMember(
+                    memberAddr, doConnect, uint32(currentContext.timestamp)
+                )
+            );
 
-    /// @inheritdoc IGeneralDistributionAgreementV1
-    function connectPool(ISuperfluidPool pool, bytes calldata ctx) external override returns (bytes memory newCtx) {
-        return connectPool(pool, true, ctx);
-    }
+            emit PoolConnectionUpdated(token, pool, memberAddr, doConnect, currentContext.userData);
+        }
 
-    /// @inheritdoc IGeneralDistributionAgreementV1
-    function disconnectPool(ISuperfluidPool pool, bytes calldata ctx) external override returns (bytes memory newCtx) {
-        return connectPool(pool, false, ctx);
+        return true;
     }
 
     /// @inheritdoc IGeneralDistributionAgreementV1
@@ -533,21 +590,6 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         }
     }
 
-    function _getPoolAdminNFTAddress(ISuperfluidToken token) internal view returns (address poolAdminNFTAddress) {
-        // solhint-disable-next-line avoid-low-level-calls
-        (bool success, bytes memory data) =
-            address(token).staticcall(abi.encodeWithSelector(ISuperToken.POOL_ADMIN_NFT.selector));
-
-        if (success) {
-            // @note We are aware this may revert if a Custom SuperToken's
-            // POOL_ADMIN_NFT does not return data that can be
-            // decoded to an address. This would mean it was intentionally
-            // done by the creator of the Custom SuperToken logic and is
-            // fully expected to revert in that case as the author desired.
-            poolAdminNFTAddress = abi.decode(data, (address));
-        }
-    }
-
     function _adjustBuffer
         (ISuperfluidToken token,
          address pool,

packages/ethereum-contracts/contracts/agreements/gdav1/SuperfluidPool.sol

@@ -123,8 +123,8 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         ISuperfluidToken superToken_,
         bool transferabilityForUnitsOwner_,
         bool distributionFromAnyAddress_,
-        string memory erc20Name_,
-        string memory erc20Symbol_,
+        string calldata erc20Name_,
+        string calldata erc20Symbol_,
         uint8 erc20Decimals_
     ) external initializer {
         admin = admin_;

packages/ethereum-contracts/contracts/agreements/gdav1/SuperfluidPoolDeployerLibrary.sol

@@ -5,14 +5,18 @@ import { BeaconProxy } from "@openzeppelin/contracts/proxy/beacon/BeaconProxy.so
 import { ISuperfluidToken } from "../../interfaces/superfluid/ISuperfluidToken.sol";
 import { SuperfluidPool } from "./SuperfluidPool.sol";
 import { PoolConfig, PoolERC20Metadata } from "../../interfaces/agreements/gdav1/IGeneralDistributionAgreementV1.sol";
+import { ISuperToken } from "../../interfaces/superfluid/ISuperToken.sol";
+import { ISuperfluidPool } from "../../interfaces/agreements/gdav1/ISuperfluidPool.sol";
+import { IPoolAdminNFT } from "../../interfaces/agreements/gdav1/IPoolAdminNFT.sol";
+
 
 library SuperfluidPoolDeployerLibrary {
     function deploy(
         address beacon,
         address admin,
         ISuperfluidToken token,
-        PoolConfig memory config,
-        PoolERC20Metadata memory poolERC20Metadata
+        PoolConfig calldata config,
+        PoolERC20Metadata calldata poolERC20Metadata
     ) external returns (SuperfluidPool pool) {
         bytes memory initializeCallData = abi.encodeWithSelector(
             SuperfluidPool.initialize.selector,
@@ -30,4 +34,25 @@ library SuperfluidPoolDeployerLibrary {
         );
         pool = SuperfluidPool(address(superfluidPoolBeaconProxy));
     }
+
+    // This was moved out of GeneralDistributionAgreementV1.sol to reduce the contract size.
+    function mintPoolAdminNFT(ISuperfluidToken token, ISuperfluidPool pool) external {
+        address poolAdminNFTAddress;
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory data) =
+            address(token).staticcall(abi.encodeWithSelector(ISuperToken.POOL_ADMIN_NFT.selector));
+
+        if (success) {
+            // @note We are aware this may revert if a Custom SuperToken's
+            // POOL_ADMIN_NFT does not return data that can be
+            // decoded to an address. This would mean it was intentionally
+            // done by the creator of the Custom SuperToken logic and is
+            // fully expected to revert in that case as the author desired.
+            poolAdminNFTAddress = abi.decode(data, (address));
+        }
+
+        if (poolAdminNFTAddress != address(0)) {
+            IPoolAdminNFT(poolAdminNFTAddress).mint(address(pool));
+        }
+    }
 }

packages/ethereum-contracts/contracts/apps/CFASuperAppBase.sol

@@ -1,7 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >= 0.8.11;
 
-import { ISuperfluid, ISuperToken, ISuperApp, SuperAppDefinitions } from "../interfaces/superfluid/ISuperfluid.sol";
+import {
+    ISuperfluid,
+    ISuperToken,
+    ISuperApp,
+    SuperAppDefinitions,
+    IGeneralDistributionAgreementV1
+} from "../interfaces/superfluid/ISuperfluid.sol";
 import { SuperTokenV1Library } from "./SuperTokenV1Library.sol";
 
 /**
@@ -39,6 +45,16 @@ abstract contract CFASuperAppBase is ISuperApp {
      */
     constructor(ISuperfluid host_) {
         HOST = host_;
+
+        // disable autoconnect for GDA pools
+        IGeneralDistributionAgreementV1 gda = IGeneralDistributionAgreementV1(
+            address(
+                ISuperfluid(host_).getAgreementClass(
+                    keccak256("org.superfluid-finance.agreements.GeneralDistributionAgreement.v1")
+                )
+            )
+        );
+        gda.setConnectPermission(false);
     }
 
     /**