f: rename RCV

Author: matiasedgeandnode

packages/horizon/contracts/interfaces/IRecurringCollector.sol

@@ -13,27 +13,27 @@ import { IAuthorizable } from "./IAuthorizable.sol";
  * recurrent payments.
  */
 interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
-    /// @notice A representation of a signed Recurrent Collection Voucher (RCV)
-    struct SignedRCV {
-        // The RCV
-        RecurrentCollectionVoucher rcv;
+    /// @notice A representation of a signed Recurring Collection Agreement (RCA)
+    struct SignedRCA {
+        // The RCA
+        RecurringCollectionAgreement rca;
         // Signature - 65 bytes: r (32 Bytes) || s (32 Bytes) || v (1 Byte)
         bytes signature;
     }
 
-    /// @notice The Recurrent Collection Voucher (RCV)
-    struct RecurrentCollectionVoucher {
-        // The agreement ID of the RCV
+    /// @notice The Recurring Collection Agreement (RCA)
+    struct RecurringCollectionAgreement {
+        // The agreement ID of the RCA
         bytes16 agreementId;
-        // The deadline for accepting the RCV
+        // The deadline for accepting the RCA
         uint256 acceptDeadline;
-        // The duration of the RCV in seconds
+        // The duration of the RCA in seconds
         uint256 duration;
-        // The address of the payer the RCV was issued by
+        // The address of the payer the RCA was issued by
         address payer;
-        // The address of the data service the RCV was issued to
+        // The address of the data service the RCA was issued to
         address dataService;
-        // The address of the service provider the RCV was issued to
+        // The address of the service provider the RCA was issued to
         address serviceProvider;
         // The maximum amount of tokens that can be collected in the first collection
         // on top of the amount allowed for subsequent collections
@@ -96,12 +96,12 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
     }
 
     /**
-     * @notice Emitted when an RCV is collected
+     * @notice Emitted when an RCA is collected
      * @param dataService The address of the data service
      * @param payer The address of the payer
      * @param serviceProvider The address of the service provider
      */
-    event RCVCollected(
+    event RCACollected(
         address indexed dataService,
         address indexed payer,
         address indexed serviceProvider,
@@ -117,9 +117,9 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
     error RecurringCollectorAgreementAcceptanceElapsed(uint256 elapsedAt);
 
     /**
-     * Thrown when the RCV signer is invalid
+     * Thrown when the RCA signer is invalid
      */
-    error RecurringCollectorInvalidRCVSigner();
+    error RecurringCollectorInvalidRCASigner();
 
     /**
      * Thrown when the payment type is not IndexingFee
@@ -128,7 +128,7 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
     error RecurringCollectorInvalidPaymentType(IGraphPayments.PaymentTypes paymentType);
 
     /**
-     * Thrown when the caller is not the data service the RCV was issued to
+     * Thrown when the caller is not the data service the RCA was issued to
      * @param caller The address of the caller
      * @param dataService The address of the data service
      */
@@ -192,9 +192,9 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
 
     /**
      * @dev Accept an indexing agreement.
-     * @param signedRCV The signed Recurrent Collection Voucher which is to be accepted.
+     * @param signedRCA The signed Recurring Collection Agreement which is to be accepted.
      */
-    function accept(SignedRCV memory signedRCV) external;
+    function accept(SignedRCA memory signedRCA) external;
 
     /**
      * @dev Cancel an indexing agreement.
@@ -207,21 +207,21 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
     /**
      * @dev Upgrade an indexing agreement.
      * @param oldAgreementId The agreement ID of the old agreement.
-     * @param signedRCV The signed Recurrent Collection Voucher of the new agreement.
+     * @param signedRCA The signed Recurring Collection Agreement of the new agreement.
      */
-    function upgrade(bytes16 oldAgreementId, SignedRCV memory signedRCV) external;
+    function upgrade(bytes16 oldAgreementId, SignedRCA memory signedRCA) external;
 
     /**
-     * @dev Computes the hash of a RecurrentCollectionVoucher (RCV).
-     * @param rcv The RCV for which to compute the hash.
-     * @return The hash of the RCV.
+     * @dev Computes the hash of a RecurringCollectionAgreement (RCA).
+     * @param rca The RCA for which to compute the hash.
+     * @return The hash of the RCA.
      */
-    function encodeRCV(RecurrentCollectionVoucher calldata rcv) external view returns (bytes32);
+    function encodeRCA(RecurringCollectionAgreement calldata rca) external view returns (bytes32);
 
     /**
-     * @dev Recovers the signer address of a signed RecurrentCollectionVoucher (RCV).
-     * @param signedRCV The SignedRCV containing the RCV and its signature.
+     * @dev Recovers the signer address of a signed RecurringCollectionAgreement (RCA).
+     * @param signedRCA The SignedRCA containing the RCA and its signature.
      * @return The address of the signer.
      */
-    function recoverRCVSigner(SignedRCV calldata signedRCV) external view returns (address);
+    function recoverRCASigner(SignedRCA calldata signedRCA) external view returns (address);
 }

packages/horizon/contracts/payments/collectors/RecurringCollector.sol

@@ -13,16 +13,16 @@ import { PPMMath } from "../../libraries/PPMMath.sol";
 /**
  * @title RecurringCollector contract
  * @dev Implements the {IRecurringCollector} interface.
- * @notice A payments collector contract that can be used to collect payments using a RCV (Recurrent Collection Voucher).
+ * @notice A payments collector contract that can be used to collect payments using a RCA (Recurring Collection Agreement).
  * @custom:security-contact Please email [email protected] if you find any
  * bugs. We may have an active bug bounty program.
  */
 contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringCollector {
     using PPMMath for uint256;
 
-    /// @notice The EIP712 typehash for the RecurrentCollectionVoucher struct
-    bytes32 private constant EIP712_RCV_TYPEHASH =
-        keccak256("RecurrentCollectionVoucher(address dataService,address serviceProvider,bytes metadata)");
+    /// @notice The EIP712 typehash for the RecurringCollectionAgreement struct
+    bytes32 private constant EIP712_RCA_TYPEHASH =
+        keccak256("RecurringCollectionAgreement(address dataService,address serviceProvider,bytes metadata)");
 
     /// @notice Sentinel value to indicate an agreement has been canceled
     uint256 private constant CANCELED = type(uint256).max;
@@ -57,7 +57,7 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     /**
      * @notice Initiate a payment collection through the payments protocol.
      * See {IGraphPayments.collect}.
-     * @dev Caller must be the data service the RCV was issued to.
+     * @dev Caller must be the data service the RCA was issued to.
      */
     function collect(IGraphPayments.PaymentTypes paymentType, bytes calldata data) external returns (uint256) {
         require(
@@ -74,10 +74,10 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     /**
      * @notice Accept an indexing agreement.
      * See {IRecurringCollector.accept}.
-     * @dev Caller must be the data service the RCV was issued to.
+     * @dev Caller must be the data service the RCA was issued to.
      */
-    function accept(SignedRCV memory signedRCV) external onlyDataService(signedRCV.rcv.dataService) {
-        _accept(signedRCV);
+    function accept(SignedRCA memory signedRCA) external onlyDataService(signedRCA.rca.dataService) {
+        _accept(signedRCA);
     }
 
     /**
@@ -92,26 +92,26 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     /**
      * @notice Upgrade an indexing agreement.
      * See {IRecurringCollector.upgrade}.
-     * @dev Caller must be the data service the RCV was issued to.
+     * @dev Caller must be the data service the RCA was issued to.
      */
     function upgrade(
         bytes16 oldAgreementId,
-        SignedRCV memory signedRCV
-    ) external onlyDataService(signedRCV.rcv.dataService) {
-        _cancel(signedRCV.rcv.dataService, signedRCV.rcv.payer, signedRCV.rcv.serviceProvider, oldAgreementId);
-        _accept(signedRCV);
+        SignedRCA memory signedRCA
+    ) external onlyDataService(signedRCA.rca.dataService) {
+        _cancel(signedRCA.rca.dataService, signedRCA.rca.payer, signedRCA.rca.serviceProvider, oldAgreementId);
+        _accept(signedRCA);
         AgreementKey memory oldKey = AgreementKey({
-            dataService: signedRCV.rcv.dataService,
-            payer: signedRCV.rcv.payer,
-            serviceProvider: signedRCV.rcv.serviceProvider,
+            dataService: signedRCA.rca.dataService,
+            payer: signedRCA.rca.payer,
+            serviceProvider: signedRCA.rca.serviceProvider,
             agreementId: oldAgreementId
         });
         AgreementData memory oldAgreement = _getAgreement(oldKey);
         AgreementKey memory key = AgreementKey({
-            dataService: signedRCV.rcv.dataService,
-            payer: signedRCV.rcv.payer,
-            serviceProvider: signedRCV.rcv.serviceProvider,
-            agreementId: signedRCV.rcv.agreementId
+            dataService: signedRCA.rca.dataService,
+            payer: signedRCA.rca.payer,
+            serviceProvider: signedRCA.rca.serviceProvider,
+            agreementId: signedRCA.rca.agreementId
         });
         AgreementData storage agreement = _getForUpdateAgreement(key);
         agreement.acceptedAt = oldAgreement.acceptedAt;
@@ -120,17 +120,17 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     }
 
     /**
-     * @notice See {IRecurringCollector.recoverRCVSigner}
+     * @notice See {IRecurringCollector.recoverRCASigner}
      */
-    function recoverRCVSigner(SignedRCV calldata signedRCV) external view returns (address) {
-        return _recoverRCVSigner(signedRCV);
+    function recoverRCASigner(SignedRCA calldata signedRCA) external view returns (address) {
+        return _recoverRCASigner(signedRCA);
     }
 
     /**
-     * @notice See {IRecurringCollector.encodeRCV}
+     * @notice See {IRecurringCollector.encodeRCA}
      */
-    function encodeRCV(RecurrentCollectionVoucher calldata rcv) external view returns (bytes32) {
-        return _encodeRCV(rcv);
+    function encodeRCA(RecurringCollectionAgreement calldata rca) external view returns (bytes32) {
+        return _encodeRCA(rca);
     }
 
     /**
@@ -142,9 +142,9 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
 
     /**
      * @notice Collect payment through the payments protocol.
-     * @dev Caller must be the data service the RCV was issued to.
+     * @dev Caller must be the data service the RCA was issued to.
      *
-     * Emits {PaymentCollected} and {RCVCollected} events.
+     * Emits {PaymentCollected} and {RCACollected} events.
      *
      * @param _params The decoded parameters for the collection
      * @return The amount of tokens collected
@@ -170,7 +170,7 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
             _params.tokens
         );
 
-        emit RCVCollected(
+        emit RCACollected(
             _params.key.dataService,
             _params.key.payer,
             _params.key.serviceProvider,
@@ -185,20 +185,20 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     /**
      * @notice See {IRecurringCollector.accept}
      */
-    function _accept(SignedRCV memory _signedRCV) private {
+    function _accept(SignedRCA memory _signedRCA) private {
         require(
-            _signedRCV.rcv.acceptDeadline >= block.timestamp,
-            RecurringCollectorAgreementAcceptanceElapsed(_signedRCV.rcv.acceptDeadline)
+            _signedRCA.rca.acceptDeadline >= block.timestamp,
+            RecurringCollectorAgreementAcceptanceElapsed(_signedRCA.rca.acceptDeadline)
         );
 
         // check that the voucher is signed by the payer (or proxy)
-        _requireAuthorizedRCVSigner(_signedRCV);
+        _requireAuthorizedRCASigner(_signedRCA);
 
         AgreementKey memory key = AgreementKey({
-            dataService: _signedRCV.rcv.dataService,
-            payer: _signedRCV.rcv.payer,
-            serviceProvider: _signedRCV.rcv.serviceProvider,
-            agreementId: _signedRCV.rcv.agreementId
+            dataService: _signedRCA.rca.dataService,
+            payer: _signedRCA.rca.payer,
+            serviceProvider: _signedRCA.rca.serviceProvider,
+            agreementId: _signedRCA.rca.agreementId
         });
         AgreementData storage agreement = _getForUpdateAgreement(key);
         // check that the agreement is not already accepted
@@ -207,11 +207,11 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
         // accept the agreement
         agreement.acceptedAt = block.timestamp;
         // FIX-ME: These need to be validated to something that makes sense for the contract
-        agreement.duration = _signedRCV.rcv.duration;
-        agreement.maxInitialTokens = _signedRCV.rcv.maxInitialTokens;
-        agreement.maxOngoingTokensPerSecond = _signedRCV.rcv.maxOngoingTokensPerSecond;
-        agreement.minSecondsPerCollection = _signedRCV.rcv.minSecondsPerCollection;
-        agreement.maxSecondsPerCollection = _signedRCV.rcv.maxSecondsPerCollection;
+        agreement.duration = _signedRCA.rca.duration;
+        agreement.maxInitialTokens = _signedRCA.rca.maxInitialTokens;
+        agreement.maxOngoingTokensPerSecond = _signedRCA.rca.maxOngoingTokensPerSecond;
+        agreement.minSecondsPerCollection = _signedRCA.rca.minSecondsPerCollection;
+        agreement.maxSecondsPerCollection = _signedRCA.rca.maxSecondsPerCollection;
     }
 
     /**
@@ -265,32 +265,32 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
     }
 
     /**
-     * @notice See {IRecurringCollector.recoverRCVSigner}
+     * @notice See {IRecurringCollector.recoverRCASigner}
      */
-    function _recoverRCVSigner(SignedRCV memory _signedRCV) private view returns (address) {
-        bytes32 messageHash = _encodeRCV(_signedRCV.rcv);
-        return ECDSA.recover(messageHash, _signedRCV.signature);
+    function _recoverRCASigner(SignedRCA memory _signedRCA) private view returns (address) {
+        bytes32 messageHash = _encodeRCA(_signedRCA.rca);
+        return ECDSA.recover(messageHash, _signedRCA.signature);
     }
 
     /**
-     * @notice See {IRecurringCollector.encodeRCV}
+     * @notice See {IRecurringCollector.encodeRCA}
      */
-    function _encodeRCV(RecurrentCollectionVoucher memory _rcv) private view returns (bytes32) {
+    function _encodeRCA(RecurringCollectionAgreement memory _rca) private view returns (bytes32) {
         return
             _hashTypedDataV4(
                 keccak256(
-                    abi.encode(EIP712_RCV_TYPEHASH, _rcv.dataService, _rcv.serviceProvider, keccak256(_rcv.metadata))
+                    abi.encode(EIP712_RCA_TYPEHASH, _rca.dataService, _rca.serviceProvider, keccak256(_rca.metadata))
                 )
             );
     }
 
     /**
-     * @notice Requires that the signer for the RCV is authorized
-     * by the payer of the RCV.
+     * @notice Requires that the signer for the RCA is authorized
+     * by the payer of the RCA.
      */
-    function _requireAuthorizedRCVSigner(SignedRCV memory _signedRCV) private view returns (address) {
-        address signer = _recoverRCVSigner(_signedRCV);
-        require(_isAuthorized(_signedRCV.rcv.payer, signer), RecurringCollectorInvalidRCVSigner());
+    function _requireAuthorizedRCASigner(SignedRCA memory _signedRCA) private view returns (address) {
+        address signer = _recoverRCASigner(_signedRCA);
+        require(_isAuthorized(_signedRCA.rca.payer, signer), RecurringCollectorInvalidRCASigner());
 
         return signer;
     }