superfluid-org · hellwolf · Aug 7, 2025 · Jun 26, 2025 · Jun 26, 2025 · Jun 30, 2025
diff --git a/packages/automation-contracts/autowrap/foundry.toml b/packages/automation-contracts/autowrap/foundry.toml
@@ -3,7 +3,7 @@ root = '../../../'
 libs = ['lib']
 src = 'packages/automation-contracts/autowrap'
 solc_version = "0.8.23"
-evm_version = 'paris'
+evm_version = 'shanghai'
 optimizer = true
 optimizer_runs = 200
 remappings = [

diff --git a/packages/automation-contracts/scheduler/foundry.toml b/packages/automation-contracts/scheduler/foundry.toml
@@ -3,7 +3,7 @@ root = '../../../'
 libs = ['lib']
 src = 'packages/automation-contracts/scheduler'
 solc_version = "0.8.23"
-evm_version = 'paris'
+evm_version = 'shanghai'
 optimizer = true
 optimizer_runs = 200
 remappings = [

@@ -5,11 +5,15 @@ 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.
+- 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).

@@ -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,
@@ -48,6 +48,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;
+
+    bytes32 constant public ACL_POOL_CONNECT_EXCLUSIVE_ROLE = keccak256("ACL_POOL_CONNECT_EXCLUSIVE_ROLE");
+    bytes32 constant public ACL_POOL_CONNECT_EXCLUSIVE_ROLE_ADMIN = keccak256("ACL_POOL_CONNECT_EXCLUSIVE_ROLE_ADMIN");
+
     /// @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
@@ -305,49 +311,100 @@ 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;
+        _setPoolConnection(pool, address(0), true, false, ctx);
+    }
+
+    /// @inheritdoc IGeneralDistributionAgreementV1
+    function tryConnectPoolFor(ISuperfluidPool pool, address memberAddr, bytes calldata ctx) 
+        external
+        override
+        returns (bool success, bytes memory newCtx)
+    {
+        newCtx = ctx;
+
+        // 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 = _setPoolConnection(pool, memberAddr, true, true, 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;
+        _setPoolConnection(pool, address(0), false, true /* ignored */, ctx);
+    }
+
+    // @note memberAddr has override semantics - if set to address(0), it will be set to the msgSender
+    function _setPoolConnection(
+        ISuperfluidPool pool,
+        address memberAddr,
+        bool doConnect,
+        bool onlyAutoConnectSlots,
+        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)
-                )
-            );
 
+        if (memberAddr == address(0)) {
+            memberAddr = currentContext.msgSender;
+        }
+
+        bool isConnected = token.isPoolMemberConnected(this, pool, memberAddr);
+
+        if (doConnect != isConnected) {
             if (doConnect) {
-                uint32 poolSlotId =
-                    _findAndFillPoolConnectionsBitmap(token, msgSender, bytes32(uint256(uint160(address(pool)))));
+                if (onlyAutoConnectSlots) {
+                    // check if we're below the slot limit for autoconnect
+                    (uint32[] memory slotIds, ) = SlotsBitmapLibrary.listData(
+                        token, memberAddr, _POOL_SUBS_BITMAP_STATE_SLOT_ID, _POOL_CONNECTIONS_DATA_STATE_SLOT_ID_START
+                    );
+                    if (slotIds.length >= 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

@@ -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_;

@@ -11,8 +11,8 @@ library SuperfluidPoolDeployerLibrary {
         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,

@@ -214,6 +214,23 @@ abstract contract IGeneralDistributionAgreementV1 is ISuperAgreement {
     /// @return newCtx the new context bytes
     function connectPool(ISuperfluidPool pool, bytes calldata ctx) external virtual returns (bytes memory newCtx);
 
+    /// @notice Allows the pool admin to connect a member to the pool if autoconnect slots are available.
+    /// "autoconnect slots" are a subset of the slots available to pool members themselves.
+    /// @param pool The pool address
+    /// @param memberAddr The member address
+    /// @param ctx Context bytes
+    /// @return success true if the member was (or remained) connected, false otherwise
+    /// @return newCtx the new context bytes
+    function tryConnectPoolFor(ISuperfluidPool pool, address memberAddr, bytes calldata ctx) 
+        external
+        virtual
+        returns (bool success, bytes memory newCtx);
+
+    /// @notice Lets accounts deny or allow 3rd parties to connect them to pools.
+    /// By default, this permission is given (except by accounts which are Super Apps).
+    /// @param allow true to allow, false to deny
+    function setConnectPermission(bool allow) external virtual;
+
     /// @notice Disconnects `msg.sender` from `pool`.
     /// @dev This is used to disconnect a pool from the GDA.
     /// @param pool The pool address

@@ -12,8 +12,8 @@ import {ISuperfluidToken} from "../interfaces/superfluid/ISuperfluidToken.sol";
  * - A data slot can be enabled or disabled with the help of bitmap.
  * - MAX_NUM_SLOTS is 256 in this implementation (using one uint256)
  * - Superfluid token storage usage:
- *   - getAgreementStateSlot(bitmapStateSlotId) stores the bitmap of enabled data slots
- *   - getAgreementStateSlot(dataStateSlotIDStart + stotId) stores the data of the slot
+ *   - updateAgreementStateSlot(bitmapStateSlotId) stores the bitmap of enabled data slots
+ *   - updateAgreementStateSlot(dataStateSlotIDStart + stotId) stores the data of the slot
  */
 library SlotsBitmapLibrary {
 

@@ -194,6 +194,15 @@ contract SuperfluidFrameworkDeploymentSteps {
                 gdaV1Logic.superfluidPoolBeacon().upgradeTo(address(superfluidPoolLogic));
                 gdaV1Logic.superfluidPoolBeacon().transferOwnership(address(host));
             }
+
+            SimpleACL(address(host.getSimpleACL())).setRoleAdmin(
+                gdaV1.ACL_POOL_CONNECT_EXCLUSIVE_ROLE(),
+                gdaV1.ACL_POOL_CONNECT_EXCLUSIVE_ROLE_ADMIN()
+            );
+            SimpleACL(address(host.getSimpleACL())).grantRole(
+                gdaV1.ACL_POOL_CONNECT_EXCLUSIVE_ROLE_ADMIN(),
+                address(gdaV1)
+            );
         } else if (step == 3) {// PERIPHERAL CONTRACTS: NFT Proxy and Logic
             {
                 poolAdminNFT = PoolAdminNFT(address(ProxyDeployerLibrary.deployUUPSProxy()));

@@ -8,7 +8,7 @@ ignored_error_codes = [
     1699 # assembly { selfdestruct } in contracts/mocks/SuperfluidDestructorMock.sol
 ]
 # keep in sync with truffle-config.js
-evm_version = 'paris'
+evm_version = 'shanghai'
 optimizer = true
 optimizer_runs = 200
 remappings = [

@@ -99,7 +99,7 @@ const config: HardhatUserConfig = {
                 enabled: true,
                 runs: 200,
             },
-            evmVersion: "paris",
+            evmVersion: "shanghai",
         },
     },
     paths: {