test: right asset custodian

Author: geolffreym

.github/workflows/cov-badge.svg

@@ -7,6 +7,7 @@ pragma solidity 0.8.26;
 /// @dev This interface defines the mechanism for transferring collected fees to the treasury.
 interface IFeesCollector {
     /// @notice Disburses funds from the contract to the treasury.
-    /// @param currency The address of the ERC20 token to disburse tokens.
-    function disburse(address currency) external returns (uint256);
+    /// @param amount The amount of tokens to disburse.
+    /// @param currency The address of the token to disburse tokens.
+    function disburse(uint256 amount, address currency) external returns (uint256);
 }

contracts/core/interfaces/economics/IFeesCollector.sol

@@ -1,20 +1,47 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity 0.8.26;
 
-/// @title IRightsRedundancyManager
-/// @notice Interface for managing redundancy limits for custodians.
+/// @title IRightsAssetCustodianManager
+/// @notice Interface for managing custodian assignment priorities, redundancy limits, and weight calculations.
 interface IRightsAssetCustodianManager {
     /// @notice Sets a custom priority value for a specific custodian assigned to the caller.
     /// @dev Influences the weighting in the balancing algorithm used to select custodians.
     /// @param custodian The custodian whose priority is being set.
     /// @param priority The priority value to assign. Must be >= 1.
     function setPriority(address custodian, uint256 priority) external;
 
+    /// @notice Sets the maximum allowed number of custodians per holder.
+    /// @param value The new maximum redundancy value.
+    function setMaxAllowedRedundancy(uint256 value) external;
+
     /// @notice Returns the maximum allowed number of custodians per holder.
     /// @return The maximum redundancy value.
     function getMaxAllowedRedundancy() external view returns (uint256);
 
-    /// @notice Sets the maximum allowed number of custodians per holder.
-    /// @param value The new maximum redundancy value.
-    function setMaxAllowedRedundancy(uint256 value) external;
+    /// @notice Retrieves the priority level associated with a specific custodian and holder.
+    /// @param custodian The address of the custodian whose priority is being queried.
+    /// @param holder The address of the holder associated with the custodian.
+    /// @return The priority level as a uint256 value.
+    function getPriority(address custodian, address holder) external view returns (uint256);
+
+    /// @notice Returns a custodian selected by a probabilistic balancing algorithm.
+    /// @dev The selection is based on priority, demand and economic weight (balance).
+    /// @param holder The address of the asset holder requesting a custodian.
+    /// @param currency The currency used to evaluate the custodian's balance.
+    /// @return The selected custodian address.
+    function getCustodian(address holder, address currency) external view returns (address);
+
+    /// @notice Calculates the weighted score of a custodian for a specific holder and currency.
+    /// @dev Used to externally query the score that influences custodian selection.
+    /// @param custodian The address of the custodian.
+    /// @param holder The address of the rights holder.
+    /// @param currency The token used to evaluate economic backing.
+    /// @return The computed weight used in the balancing algorithm.
+    function getWeight(address custodian, address holder, address currency) external view returns (uint256);
+
+    /// @notice Retrieves the total number of holders assigned to a custodian.
+    /// @dev Represents the current load (demand) of a custodian in terms of assignments.
+    /// @param custodian The custodian address to query.
+    /// @return The number of holders currently assigned to the custodian.
+    function getDemand(address custodian) external view returns (uint256);
 }

contracts/core/interfaces/rights/IRightsAssetCustodianManager.sol

@@ -4,7 +4,6 @@ pragma solidity 0.8.26;
 
 /// @title IRightsAssetCustodianVerifiable
 /// @notice Interface for verifying custodian assignments and querying custody-related data.
-/// @dev Includes read-access functions used in balancing and audit operations.
 interface IRightsAssetCustodianVerifiable {
     /// @notice Checks whether a custodian is currently assigned to a holder.
     /// @dev Returns true only if the custodian is active and listed for the specified holder.
@@ -13,24 +12,5 @@ interface IRightsAssetCustodianVerifiable {
     /// @return True if `custodian` is valid and assigned to `holder`, false otherwise.
     function isCustodian(address custodian, address holder) external view returns (bool);
 
-    /// @notice Returns a custodian selected by a probabilistic balancing algorithm.
-    /// @dev The selection is based on priority, demand and economic weight (balance).
-    /// @param holder The address of the asset holder requesting a custodian.
-    /// @param currency The currency used to evaluate the custodian's balance.
-    /// @return The selected custodian address.
-    function getBalancedCustodian(address holder, address currency) external view returns (address);
 
-    /// @notice Retrieves the total number of holders assigned to a custodian.
-    /// @dev Represents the current load (demand) of a custodian in terms of assignments.
-    /// @param custodian The custodian address to query.
-    /// @return The number of holders currently assigned to the custodian.
-    function getCustodyCount(address custodian) external view returns (uint256);
-
-    /// @notice Calculates the weighted score of a custodian for a specific holder and currency.
-    /// @dev Used to externally query the score that influences custodian selection.
-    /// @param custodian The address of the custodian.
-    /// @param holder The address of the rights holder.
-    /// @param currency The token used to evaluate economic backing.
-    /// @return The computed weight used in the balancing algorithm.
-    function calcWeight(address custodian, address holder, address currency) external view returns (uint256);
 }

contracts/core/interfaces/rights/IRightsAssetCustodianVerifiable.sol

@@ -45,7 +45,7 @@ library T {
         address initiator; // the initiator of the transaction
         uint256 total; // the transaction total amount
         uint256 fees; // the agreement protocol fees
-        address[] parties; // the accounts related to agreement
+        address[] parties; // the accounts or beneficiaries bounded to the agreement
         bytes payload; // any additional data needed during agreement execution
     }
 

contracts/core/primitives/Types.sol

@@ -44,20 +44,6 @@ abstract contract FeesCollectorUpgradeable is Initializable, IFeesCollector {
         _;
     }
 
-    /// @notice Disburses all collected funds of a specified currency from the contract to the treasury. (visitor)
-    /// @dev This function can only be called by the treasury. It transfers the full balance of the specified currency.
-    /// @param currency The address of the ERC20 token to disburse.
-    function disburse(address currency) external virtual onlyTreasury returns (uint256) {
-        // Transfer all funds of the specified currency to the treasury.
-        address treasuryAddress = getTreasuryAddress();
-        uint256 amount = address(this).balanceOf(currency);
-        if (amount == 0) return 0; // error trying transfer zero amount..
-        // safe direct transfer to treasury address..
-        treasuryAddress.transfer(amount, currency);
-        emit FeesDisbursed(treasuryAddress, amount, currency);
-        return amount;
-    }
-
     /// @notice Returns the current address of the treasury.
     /// @return The address of the treasury.
     function getTreasuryAddress() public view returns (address) {

contracts/core/primitives/upgradeable/FeesCollectorUpgradeable.sol

@@ -59,6 +59,9 @@ contract CustodianFactory is UpgradeableBeacon, ICustodianFactory {
         return _manager[custodian] != address(0);
     }
 
+    // TODO endpoint expected as multi-address
+    // potential validation needed here
+
     /// @notice Function to create a new custodian contract.
     /// @dev Ensures that the same endpoint is not registered twice.
     /// @param endpoint The endpoint associated with the new custodian.

contracts/custody/CustodianFactory.sol

@@ -64,6 +64,8 @@ contract CustodianImpl is
         return owner();
     }
 
+    
+    /// TODO add method to return encoded multi-address. getAddress()
     /// @notice Returns the current distribution endpoint URL.
     function getEndpoint() external view returns (string memory) {
         return _endpoint;
@@ -75,7 +77,7 @@ contract CustodianImpl is
     function setEndpoint(string calldata endpoint_) external onlyOwner {
         if (bytes(endpoint_).length == 0) revert InvalidEndpoint();
         string memory oldEndpoint = _endpoint;
-        _endpoint = endpoint_;
+        _endpoint = endpoint_; // update the endpoint!
         emit EndpointUpdated(oldEndpoint, endpoint_);
     }
 
@@ -97,7 +99,7 @@ contract CustodianImpl is
     /// @notice Retrieves the contract's balance for a given currency.
     /// @param currency The token address to check the balance of (use `address(0)` for native currency).
     /// @dev This function is restricted to the contract owner.
-    function getBalance(address currency) public view onlyOwner returns (uint256) {
+    function getBalance(address currency) public view returns (uint256) {
         return address(this).balanceOf(currency);
     }
 }

contracts/custody/CustodianImpl.sol

@@ -170,7 +170,6 @@ contract CustodianReferendum is
         //
         // The collected fees are used to support the protocol's operations, aligning
         // individual actions with the broader sustainability of the network.
-        // !IMPORTANT If tollgate does not support the currency, will revert..
         T.Agreement memory agreement = AGREEMENT_SETTLER.settleAgreement(proof, msg.sender);
         if (agreement.parties[0] != custodian) {
             revert CustodianAgreementMismatch(custodian);

contracts/custody/CustodianReferendum.sol

@@ -73,10 +73,10 @@ contract Treasury is
     /// @param collector The address of an authorized fee collector.
     /// @param currency The address of the ERC20 token for which fees are being collected.
     function collectFees(address collector, address currency) external restricted nonReentrant {
-        IFeesCollector feesCollector = IFeesCollector(collector);
-        uint256 collected = feesCollector.disburse(currency);
-        _sumLedgerEntry(address(this), collected, currency);
-        emit FeesCollected(collector, collected, currency);
+        // IFeesCollector feesCollector = IFeesCollector(collector);
+        // uint256 collected = feesCollector.disburse(currency);
+        // _sumLedgerEntry(address(this), collected, currency);
+        // emit FeesCollected(collector, collected, currency);
     }
 
     /// @notice Function that should revert when msg.sender is not authorized to upgrade the contract.