[ETHEREUM-CONTRACTS] [GDA] Fixes for GDA

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

@@ -90,10 +90,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
     uint256 private constant _POOL_SUBS_BITMAP_STATE_SLOT_ID = 1;
     /// @dev Pool member state slot id starting point for pool connections
     uint256 private constant _POOL_CONNECTIONS_DATA_STATE_SLOT_ID_START = 1 << 128;
-    /// @dev CFAv1 PPP Config Key
-    bytes32 private constant CFAV1_PPP_CONFIG_KEY =
-        keccak256("org.superfluid-finance.agreements.ConstantFlowAgreement.v1.PPPConfiguration");
-
+    /// @dev SuperToken minimum deposit key
     bytes32 private constant SUPERTOKEN_MINIMUM_DEPOSIT_KEY =
         keccak256("org.superfluid-finance.superfluid.superTokenMinimumDeposit");
 
@@ -105,19 +102,21 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         superfluidPoolBeacon = superfluidPoolBeacon_;
     }
 
-    function realtimeBalanceVectorAt(ISuperfluidToken token, address account, uint256 time)
+    function realtimeBalanceOf(ISuperfluidToken token, address account, uint256 time)
         public
         view
-        returns (int256 available, int256 fromPools, int256 buffer)
+        override
+        returns (int256 rtb, uint256 buf, uint256 owedBuffer)
     {
         UniversalIndexData memory universalIndexData = _getUIndexData(abi.encode(token), account);
 
         if (_isPool(token, account)) {
-            available = ISuperfluidPool(account).getDisconnectedBalance(uint32(time));
+            rtb = ISuperfluidPool(account).getDisconnectedBalance(uint32(time));
         } else {
-            available = Value.unwrap(_getBasicParticleFromUIndex(universalIndexData).rtb(Time.wrap(uint32(time))));
+            rtb = Value.unwrap(_getBasicParticleFromUIndex(universalIndexData).rtb(Time.wrap(uint32(time))));
         }
 
+        int256 fromPools;
         {
             (uint32[] memory slotIds, bytes32[] memory pidList) = _listPoolConnectionIds(token, account);
             for (uint256 i = 0; i < slotIds.length; ++i) {
@@ -126,24 +125,12 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
                     _getPoolMemberData(token, account, ISuperfluidPool(pool));
                 assert(exist);
                 assert(poolMemberData.pool == pool);
-                fromPools = fromPools + ISuperfluidPool(pool).getClaimable(account, uint32(time));
+                fromPools += ISuperfluidPool(pool).getClaimable(account, uint32(time));
             }
         }
+        rtb += fromPools;
 
-        buffer = universalIndexData.totalBuffer.toInt256();
-    }
-
-    function realtimeBalanceOf(ISuperfluidToken token, address account, uint256 time)
-        public
-        view
-        override
-        returns (int256 rtb, uint256 buf, uint256 owedBuffer)
-    {
-        (int256 available, int256 fromPools, int256 buffer) = realtimeBalanceVectorAt(token, account, time);
-        rtb = available + fromPools;
-
-        buf = uint256(buffer); // upcasting to uint256 is safe
-        owedBuffer = 0;
+        buf = uint256(universalIndexData.totalBuffer.toInt256()); // upcasting to uint256 is safe
     }
 
     /// @dev ISuperAgreement.realtimeBalanceOf implementation
@@ -322,9 +309,14 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         ISuperfluid.Context memory currentContext = AgreementLibrary.authorizeTokenAccess(token, ctx);
         address msgSender = currentContext.msgSender;
         newCtx = ctx;
+        bool isConnected = _isMemberConnected(token, address(pool), msgSender);
         if (doConnect) {
-            if (!isMemberConnected(token, address(pool), msgSender)) {
-                assert(SuperfluidPool(address(pool)).operatorConnectMember(msgSender, true, uint32(block.timestamp)));
+            if (!isConnected) {
+                assert(
+                    SuperfluidPool(address(pool)).operatorConnectMember(
+                        msgSender, true, uint32(currentContext.timestamp)
+                    )
+                );
 
                 uint32 poolSlotID =
                     _findAndFillPoolConnectionsBitmap(token, msgSender, bytes32(uint256(uint160(address(pool)))));
@@ -338,31 +330,32 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
                 );
             }
         } else {
-            if (isMemberConnected(token, address(pool), msgSender)) {
-                assert(SuperfluidPool(address(pool)).operatorConnectMember(msgSender, false, uint32(block.timestamp)));
+            if (isConnected) {
+                assert(
+                    SuperfluidPool(address(pool)).operatorConnectMember(
+                        msgSender, false, uint32(currentContext.timestamp)
+                    )
+                );
                 (, PoolMemberData memory poolMemberData) = _getPoolMemberData(token, msgSender, pool);
                 token.terminateAgreement(_getPoolMemberHash(msgSender, pool), 1);
 
                 _clearPoolConnectionsBitmap(token, msgSender, poolMemberData.poolID);
             }
         }
 
-        emit PoolConnectionUpdated(token, pool, msgSender, doConnect, currentContext.userData);
+        // we only emit PoolConnectionUpdated if the connection state has changed
+        if (doConnect && !isConnected || !doConnect && isConnected) {
+            emit PoolConnectionUpdated(token, pool, msgSender, doConnect, currentContext.userData);
+        }
     }
 
-    /// @inheritdoc IGeneralDistributionAgreementV1
-    function isMemberConnected(ISuperfluidToken token, address pool, address member)
-        public
-        view
-        override
-        returns (bool)
-    {
+    function _isMemberConnected(ISuperfluidToken token, address pool, address member) internal view returns (bool) {
         (bool exist,) = _getPoolMemberData(token, member, ISuperfluidPool(pool));
         return exist;
     }
 
-    function isMemberConnected(ISuperfluidPool pool, address member) public view override returns (bool) {
-        return isMemberConnected(pool.superToken(), address(pool), member);
+    function isMemberConnected(ISuperfluidPool pool, address member) external view override returns (bool) {
+        return _isMemberConnected(pool.superToken(), address(pool), member);
     }
 
     function appendIndexUpdateByPool(ISuperfluidToken token, BasicParticle memory p, Time t) external returns (bool) {
@@ -404,12 +397,15 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
             revert GDA_ONLY_SUPER_TOKEN_POOL();
         }
 
+        // you cannot distribute if admin is not equal to the ctx.msgSender
         if (!pool.distributionFromAnyAddress()) {
             if (pool.admin() != currentContext.msgSender) {
                 revert GDA_DISTRIBUTE_FROM_ANY_ADDRESS_NOT_ALLOWED();
             }
         }
 
+        // the from address must be the same as the ctx.msgSender
+        // there is no ACL support
         if (from != currentContext.msgSender) {
             revert GDA_DISTRIBUTE_FOR_OTHERS_NOT_ALLOWED();
         }
@@ -467,7 +463,10 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
 
         newCtx = ctx;
 
-        if (!pool.distributionFromAnyAddress()) {
+        // we must check if the requestedFlowRate is greater than 0 here
+        // otherwise we will block liquidators from closing streams in pools
+        // where the pool config has distributionFromAnyAddress set to false
+        if (requestedFlowRate > 0 && !pool.distributionFromAnyAddress()) {
             if (pool.admin() != flowVars.currentContext.msgSender) {
                 revert GDA_DISTRIBUTE_FROM_ANY_ADDRESS_NOT_ALLOWED();
             }
@@ -479,7 +478,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
             address(pool),
             flowVars.distributionFlowHash,
             FlowRate.wrap(requestedFlowRate),
-            Time.wrap(uint32(block.timestamp))
+            Time.wrap(uint32(flowVars.currentContext.timestamp))
         );
 
         // handle distribute flow on behalf of someone else
@@ -515,14 +514,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         }
 
         {
-            _adjustBuffer(
-                abi.encode(token),
-                address(pool),
-                from,
-                flowVars.distributionFlowHash,
-                flowVars.oldFlowRate,
-                actualFlowRate
-            );
+            _adjustBuffer(token, address(pool), from, flowVars.distributionFlowHash, actualFlowRate);
         }
 
         // ensure sender has enough balance to execute transaction
@@ -636,7 +628,6 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
             _getFlowDistributionData(ISuperfluidToken(data.token), data.distributionFlowHash);
         int256 signedSingleDeposit = flowDistributionData.buffer.toInt256();
 
-        bytes memory liquidationTypeData;
         bool isCurrentlyPatricianPeriod;
 
         {
@@ -652,10 +643,9 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         // critical case
         if (totalRewardLeft >= 0) {
             int256 rewardAmount = (signedSingleDeposit * totalRewardLeft) / data.signedTotalGDADeposit;
-            liquidationTypeData = abi.encode(2, isCurrentlyPatricianPeriod ? 0 : 1);
             data.token.makeLiquidationPayoutsV2(
                 data.distributionFlowHash,
-                liquidationTypeData,
+                abi.encode(2, isCurrentlyPatricianPeriod ? 0 : 1),
                 data.liquidator,
                 isCurrentlyPatricianPeriod,
                 data.sender,
@@ -677,15 +667,9 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         }
     }
 
-    function _adjustBuffer(
-        bytes memory eff,
-        address pool,
-        address from,
-        bytes32 flowHash,
-        FlowRate, // oldFlowRate,
-        FlowRate newFlowRate
-    ) internal returns (bytes memory) {
-        address token = abi.decode(eff, (address));
+    function _adjustBuffer(ISuperfluidToken token, address pool, address from, bytes32 flowHash, FlowRate newFlowRate)
+        internal
+    {
         // not using oldFlowRate in this model
         // surprising effect: reducing flow rate may require more buffer when liquidation_period adjusted upward
         ISuperfluidGovernance gov = ISuperfluidGovernance(ISuperfluid(_host).getGovernance());
@@ -718,7 +702,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
             ISuperfluidToken(token).updateAgreementData(flowHash, data);
         }
 
-        UniversalIndexData memory universalIndexData = _getUIndexData(eff, from);
+        UniversalIndexData memory universalIndexData = _getUIndexData(abi.encode(token), from);
         universalIndexData.totalBuffer =
         // new buffer
          (universalIndexData.totalBuffer.toInt256() + Value.unwrap(bufferDelta)).toUint256();
@@ -736,8 +720,6 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
                 universalIndexData.totalBuffer
             );
         }
-
-        return eff;
     }
 
     // Solvency Related Getters
@@ -810,7 +792,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         data = new bytes32[](2);
         data[0] = bytes32(
             (uint256(int256(FlowRate.unwrap(p.flow_rate()))) << 160) | (uint256(Time.unwrap(p.settled_at())) << 128)
-                | (buffer << 32) | (isPool_ ? 1 : 0)
+                | (uint256(buffer.toUint96()) << 32) | (isPool_ ? 1 : 0)
         );
         data[1] = bytes32(uint256(Value.unwrap(p._settled_value)));
     }
@@ -823,7 +805,7 @@ contract GeneralDistributionAgreementV1 is AgreementBase, TokenMonad, IGeneralDi
         data = new bytes32[](2);
         data[0] = bytes32(
             (uint256(int256(uIndexData.flowRate)) << 160) | (uint256(uIndexData.settledAt) << 128)
-                | (uint256(uIndexData.totalBuffer) << 32) | (uIndexData.isPool ? 1 : 0)
+                | (uint256(uIndexData.totalBuffer.toUint96()) << 32) | (uIndexData.isPool ? 1 : 0)
         );
         data[1] = bytes32(uint256(uIndexData.settledValue));
     }

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

@@ -302,8 +302,8 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         override
         returns (int256 claimableBalance, uint256 timestamp)
     {
-        // TODO, GDA.getHost().getTimestamp() should be used in principle
-        return (getClaimable(memberAddr, uint32(block.timestamp)), block.timestamp);
+        timestamp = ISuperfluid(superToken.getHost()).getNow();
+        return (getClaimable(memberAddr, uint32(timestamp)), timestamp);
     }
 
     /// @inheritdoc ISuperfluidPool
@@ -402,7 +402,7 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
         PDPoolMemberMU memory mu = PDPoolMemberMU(pdPoolIndex, pdPoolMember);
 
         // update pool's disconnected units
-        if (!GDA.isMemberConnected(superToken, address(this), memberAddr)) {
+        if (!GDA.isMemberConnected(ISuperfluidPool(address(this)), memberAddr)) {
             // trigger the side effect of claiming all if not connected
             // @note claiming is a bit surprising here given the function name
             int256 claimedAmount = _claimAll(memberAddr, time);
@@ -442,9 +442,8 @@ contract SuperfluidPool is ISuperfluidPool, BeaconProxiable {
 
     /// @inheritdoc ISuperfluidPool
     function claimAll(address memberAddr) public returns (bool) {
-        bool isConnected = GDA.isMemberConnected(superToken, address(this), memberAddr);
-        // TODO, GDA.getHost().getTimestamp() should be used in principle
-        uint32 time = uint32(block.timestamp);
+        bool isConnected = GDA.isMemberConnected(ISuperfluidPool(address(this)), memberAddr);
+        uint32 time = uint32(ISuperfluid(superToken.getHost()).getNow());
         int256 claimedAmount = _claimAll(memberAddr, time);
         if (!isConnected) {
             _shiftDisconnectedUnits(Unit.wrap(0), Value.wrap(claimedAmount), Time.wrap(time));

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

@@ -1055,7 +1055,7 @@ library SuperTokenV1Library {
 
     function isMemberConnected(ISuperToken token, address pool, address member) internal view returns (bool) {
         (, IGeneralDistributionAgreementV1 gda) = _getHostAndGDA(token);
-        return gda.isMemberConnected(token, pool, member);
+        return gda.isMemberConnected(ISuperfluidPool(pool), member);
     }
 
 

packages/ethereum-contracts/contracts/gov/SuperfluidGovernanceBase.sol

@@ -64,7 +64,8 @@ abstract contract SuperfluidGovernanceBase is ISuperfluidGovernance
         ISuperfluid host,
         address hostNewLogic,
         address[] calldata agreementClassNewLogics,
-        address superTokenFactoryNewLogic
+        address superTokenFactoryNewLogic,
+        address poolBeaconNewLogic
     )
         external override
         onlyAuthorized(host)
@@ -87,6 +88,9 @@ abstract contract SuperfluidGovernanceBase is ISuperfluidGovernance
             // solhint-disable-next-line no-empty-blocks
             catch {}
         }
+        if (poolBeaconNewLogic != address(0)) {
+            host.updatePoolBeaconLogic(poolBeaconNewLogic);
+        }
     }
 
     function batchUpdateSuperTokenLogic(

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

@@ -215,13 +215,6 @@ abstract contract IGeneralDistributionAgreementV1 is ISuperAgreement {
     /// Check if an address is connected to the pool
     function isMemberConnected(ISuperfluidPool pool, address memberAddr) external view virtual returns (bool);
 
-    /// Check if an address is connected to the pool
-    function isMemberConnected(ISuperfluidToken token, address pool, address memberAddr)
-        external
-        view
-        virtual
-        returns (bool);
-
     /// Get pool adjustment flow information: (recipient, flowHash, flowRate)
     function getPoolAdjustmentFlowInfo(ISuperfluidPool pool) external view virtual returns (address, bytes32, int96);
 

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

@@ -4,14 +4,14 @@ pragma solidity >=0.8.4;
 import { IERC721Metadata } from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
 
 interface IPoolNFTBase is IERC721Metadata {
-    error POOL_NFT_APPROVE_TO_CALLER();
-    error POOL_NFT_ONLY_SUPER_TOKEN_FACTORY();
-    error POOL_NFT_INVALID_TOKEN_ID();
-    error POOL_NFT_APPROVE_TO_CURRENT_OWNER();
-    error POOL_NFT_APPROVE_CALLER_NOT_OWNER_OR_APPROVED_FOR_ALL();
-    error POOL_NFT_NOT_REGISTERED_POOL();
-    error POOL_NFT_TRANSFER_NOT_ALLOWED();
-    error POOL_NFT_TRANSFER_CALLER_NOT_OWNER_OR_APPROVED_FOR_ALL();
+    error POOL_NFT_APPROVE_TO_CALLER();                             // 0x9212b333
+    error POOL_NFT_ONLY_SUPER_TOKEN_FACTORY();                      // 0x1fd7e3d8
+    error POOL_NFT_INVALID_TOKEN_ID();                              // 0x09275994
+    error POOL_NFT_APPROVE_TO_CURRENT_OWNER();                      // 0x020226d3
+    error POOL_NFT_APPROVE_CALLER_NOT_OWNER_OR_APPROVED_FOR_ALL();  // 0x1e82f255
+    error POOL_NFT_NOT_REGISTERED_POOL();                           // 0x6421912e
+    error POOL_NFT_TRANSFER_NOT_ALLOWED();                          // 0x432fb160 
+    error POOL_NFT_TRANSFER_CALLER_NOT_OWNER_OR_APPROVED_FOR_ALL(); // 0x4028ee0e
 
     /// @notice Informs third-party platforms that NFT metadata should be updated
     /// @dev This event comes from https://eips.ethereum.org/EIPS/eip-4906

packages/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluid.sol

@@ -240,6 +240,19 @@ interface ISuperfluid {
      */
     function changeSuperTokenAdmin(ISuperToken token, address newAdmin) external;
 
+    /**
+     * @notice Change the implementation address the pool beacon points to
+     * @dev Updating the logic the beacon points to will update the logic of all the Pool BeaconProxy instances
+     */
+    function updatePoolBeaconLogic(address newBeaconLogic) external;
+
+    /**
+     * @dev Pool Beacon logic updated event
+     * @param beaconProxy addrss of the beacon proxy
+     * @param newBeaconLogic address of the new beacon logic
+     */
+    event PoolBeaconLogicUpdated(address indexed beaconProxy, address newBeaconLogic);
+
     /**************************************************************************
      * App Registry
      *************************************************************************/

packages/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluidGovernance.sol

@@ -41,7 +41,8 @@ interface ISuperfluidGovernance {
         ISuperfluid host,
         address hostNewLogic,
         address[] calldata agreementClassNewLogics,
-        address superTokenFactoryNewLogic
+        address superTokenFactoryNewLogic,
+        address beaconNewLogic
     ) external;
 
     /**

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

@@ -8,7 +8,7 @@ library SafeGasLibrary {
     error OUT_OF_GAS(); // 0x20afada5
 
     function _isOutOfGas(uint256 gasLeftBefore) internal view returns (bool) {
-        return gasleft() <= gasLeftBefore / 63;
+        return gasleft() <= gasLeftBefore / 64;
     }
 
     /// @dev A function used in the catch block to handle true out of gas errors