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

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 = [

packages/automation-contracts/scheduler/contracts/VestingSchedulerV2.sol

@@ -441,7 +441,7 @@ contract VestingSchedulerV2 is IVestingSchedulerV2, SuperAppBase {
         if (!disableClaimCheck && schedule.claimValidityDate != 0) 
             revert ScheduleNotClaimed();
 
-        // Ensure that that the claming date is after the cliff/flow date and before the claim validity date
+        // Ensure that the claming date is after the cliff/flow date and before the claim validity date
         if (schedule.cliffAndFlowDate > block.timestamp || 
             _lteDateToExecuteCliffAndFlow(schedule) < block.timestamp)
                 revert TimeWindowInvalid();

packages/automation-contracts/scheduler/contracts/VestingSchedulerV3.sol

@@ -760,7 +760,7 @@ contract VestingSchedulerV3 is IVestingSchedulerV3, IRelayRecipient {
             revert ScheduleNotClaimed();
         }
 
-        // Ensure that that the claming date is after the cliff/flow date and before the claim validity date
+        // Ensure that the claming date is after the cliff/flow date and before the claim validity date
         if (schedule.cliffAndFlowDate > block.timestamp || _lteDateToExecuteCliffAndFlow(schedule) < block.timestamp) {
             revert TimeWindowInvalid();
         }

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 = [

packages/ethereum-contracts/CHANGELOG.md

@@ -11,6 +11,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   - `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.
 
+### 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).
+
 ### Breaking
 - PoolMemberNFT pruning: `IPoolMemberNFT` and `PoolMemberNFT` removed, `POOL_MEMBER_NFT()` removed from `ISuperToken`.
 

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,
@@ -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
@@ -89,7 +95,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
             for (uint256 i = 0; i < slotIds.length; ++i) {
                 address pool = address(uint160(uint256(pidList[i])));
                 _assertPoolConnectivity(token, account, ISuperfluidPool(pool));
-                totalConnectedFromPools += ISuperfluidPool(pool).getClaimable(account, uint32(time));
+                totalConnectedFromPools += SuperfluidPool(pool).getUnsettledValue(account, uint32(time));
             }
         }
         rtb += totalConnectedFromPools;
@@ -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

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

@@ -289,7 +289,7 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
             Value.unwrap(
                 // PDPoolMemberMU(poolIndex, memberData)
                 PDPoolMemberMU(poolIndexDataToPDPoolIndex(_index), _memberDataToPDPoolMember(memberData)).settle(
-                    Time.wrap(uint32(block.timestamp))
+                    Time.wrap(SafeCast.toUint32(block.timestamp))
                 ).m._settled_value
             )
         );
@@ -370,17 +370,14 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         returns (int256 claimableBalance, uint256 timestamp)
     {
         timestamp = ISuperfluid(superToken.getHost()).getNow();
-        return (getClaimable(memberAddr, uint32(timestamp)), timestamp);
+        return (getClaimable(memberAddr, SafeCast.toUint32(timestamp)), timestamp);
     }
 
     /// @inheritdoc ISuperfluidPool
     function getClaimable(address memberAddr, uint32 time) public view override returns (int256) {
-        Time t = Time.wrap(time);
-        PDPoolIndex memory pdPoolIndex = poolIndexDataToPDPoolIndex(_index);
-        PDPoolMember memory pdPoolMember = _memberDataToPDPoolMember(_membersData[memberAddr]);
-        return Value.unwrap(
-            PDPoolMemberMU(pdPoolIndex, pdPoolMember).rtb(t) - Value.wrap(_membersData[memberAddr].claimedValue)
-        );
+        return superToken.isPoolMemberConnected(GDA, this, memberAddr)
+             ? int256(0)
+             : getUnsettledValue(memberAddr, time);
     }
 
     /// @inheritdoc ISuperfluidPool
@@ -430,7 +427,7 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         if (superToken.isPool(GDA, memberAddr)) revert SUPERFLUID_POOL_NO_POOL_MEMBERS();
         if (memberAddr == address(0)) revert SUPERFLUID_POOL_NO_ZERO_ADDRESS();
 
-        uint32 time = uint32(ISuperfluid(superToken.getHost()).getNow());
+        uint32 time = SafeCast.toUint32(ISuperfluid(superToken.getHost()).getNow());
         Time t = Time.wrap(time);
         Unit wrappedUnits = toSemanticMoneyUnit(newUnits);
 
@@ -443,7 +440,7 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         PDPoolMemberMU memory mu = PDPoolMemberMU(pdPoolIndex, pdPoolMember);
 
         // update pool's disconnected units
-        if (!superToken.isPoolMemberConnected(GDA, ISuperfluidPool(address(this)), memberAddr)) {
+        if (!superToken.isPoolMemberConnected(GDA, this, memberAddr)) {
             _shiftDisconnectedUnits(wrappedUnits - mu.m.owned_units, Value.wrap(0), t);
         }
 
@@ -459,11 +456,26 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         emit MemberUnitsUpdated(superToken, memberAddr, oldUnits, newUnits);
     }
 
-    function _claimAll(address memberAddr, uint32 time) internal returns (int256 amount) {
-        amount = getClaimable(memberAddr, time);
-        assert(GDA.poolSettleClaim(superToken, memberAddr, (amount)));
+    function _settle(address memberAddr, uint32 time) internal returns (int256 amount) {
+        amount = getUnsettledValue(memberAddr, time);
+        assert(GDA.poolSettleClaim(superToken, memberAddr, amount));
         _membersData[memberAddr].claimedValue += amount;
+    }
 
+    function getUnsettledValue(address memberAddr, uint32 time) public view returns (int256) {
+        Time t = Time.wrap(time);
+        PDPoolIndex memory pdPoolIndex = poolIndexDataToPDPoolIndex(_index);
+        PDPoolMember memory pdPoolMember = _memberDataToPDPoolMember(_membersData[memberAddr]);
+        return Value.unwrap(
+            PDPoolMemberMU(pdPoolIndex, pdPoolMember).rtb(t) - Value.wrap(_membersData[memberAddr].claimedValue)
+        );
+    }
+
+    function _claimAll(address memberAddr, uint32 time) internal returns (int256 amount) {
+        // For connected pool, claimable amount is zero; hence, we skip.
+        if (!superToken.isPoolMemberConnected(GDA, this, memberAddr)) {
+            amount = _settle(memberAddr, time);
+        }
         emit DistributionClaimed(superToken, memberAddr, amount, _membersData[memberAddr].claimedValue);
     }
 
@@ -475,7 +487,7 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
     /// @inheritdoc ISuperfluidPool
     function claimAll(address memberAddr) public returns (bool) {
         bool isConnected = superToken.isPoolMemberConnected(GDA, this, memberAddr);
-        uint32 time = uint32(ISuperfluid(superToken.getHost()).getNow());
+        uint32 time = SafeCast.toUint32(ISuperfluid(superToken.getHost()).getNow());
         int256 claimedAmount = _claimAll(memberAddr, time);
         if (!isConnected) {
             _shiftDisconnectedUnits(Unit.wrap(0), Value.wrap(claimedAmount), Time.wrap(time));
@@ -492,10 +504,10 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
 
     // WARNING for operators: it is undefined behavior if member is already connected or disconnected
     function operatorConnectMember(address memberAddr, bool doConnect, uint32 time) external onlyGDA returns (bool) {
-        int256 claimedAmount = _claimAll(memberAddr, time);
+        int256 settleAmount = _settle(memberAddr, time);
         int128 units = uint256(_getUnits(memberAddr)).toInt256().toInt128();
         if (doConnect) {
-            _shiftDisconnectedUnits(Unit.wrap(-units), Value.wrap(claimedAmount), Time.wrap(time));
+            _shiftDisconnectedUnits(Unit.wrap(-units), Value.wrap(settleAmount), Time.wrap(time));
         } else {
             _shiftDisconnectedUnits(Unit.wrap(units), Value.wrap(0), Time.wrap(time));
         }

packages/ethereum-contracts/contracts/interfaces/agreements/gdav1/IGeneralDistributionAgreementV1.sol

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

packages/ethereum-contracts/contracts/libs/SlotsBitmapLibrary.sol

@@ -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 {
 

packages/ethereum-contracts/contracts/utils/SuperfluidFrameworkDeploymentSteps.t.sol

@@ -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()));

packages/ethereum-contracts/foundry.toml

@@ -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 = [

packages/ethereum-contracts/hardhat.config.ts

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

packages/ethereum-contracts/ops-scripts/deploy-framework.js

@@ -996,7 +996,7 @@ module.exports = eval(`(${S.toString()})({skipArgv: true})`)(async function (
                 const poolMemberNFTPAddr = await superTokenLogic.POOL_MEMBER_NFT();
                 let poolMemberNFTLAddr = ZERO_ADDRESS;
                 if (poolMemberNFTPAddr !== ZERO_ADDRESS) {
-                    const poolMemberNFTContract = await PoolMemberNFT.at(poolMemberNFTPAddr);
+                    const poolMemberNFTContract = await UUPSProxiable.at(poolMemberNFTPAddr);
                     poolMemberNFTLAddr = await poolMemberNFTContract.getCodeAddress();
                 }