chore: rename TAPCollector to GraphTallyCollector

Signed-off-by: Tomás Migone <[email protected]>

Author: tmigone

packages/horizon/contracts/interfaces/ITAPCollector.sol renamed to packages/horizon/contracts/interfaces/IGraphTallyCollector.sol

@@ -5,13 +5,13 @@ import { IPaymentsCollector } from "./IPaymentsCollector.sol";
 import { IGraphPayments } from "./IGraphPayments.sol";
 
 /**
- * @title Interface for the {TAPCollector} contract
+ * @title Interface for the {GraphTallyCollector} contract
  * @dev Implements the {IPaymentCollector} interface as defined by the Graph
  * Horizon payments protocol.
  * @notice Implements a payments collector contract that can be used to collect
- * payments using a TAP RAV (Receipt Aggregate Voucher).
+ * payments using a GraphTally RAV (Receipt Aggregate Voucher).
  */
-interface ITAPCollector is IPaymentsCollector {
+interface IGraphTallyCollector is IPaymentsCollector {
     /// @notice Details for a payer-signer pair
     /// @dev Signers can be removed only after a thawing period
     struct PayerAuthorization {
@@ -33,7 +33,7 @@ interface ITAPCollector is IPaymentsCollector {
         address serviceProvider;
         // The address of the data service the RAV was issued to
         address dataService;
-        // The RAV timestamp, indicating the latest TAP Receipt in the RAV
+        // The RAV timestamp, indicating the latest GraphTally Receipt in the RAV
         uint64 timestampNs;
         // Total amount owed to the service provider since the beginning of the
         // payer-service provider relationship, including all debt that is already paid for.
@@ -107,92 +107,92 @@ interface ITAPCollector is IPaymentsCollector {
      * @param authorizingPayer The address of the payer authorizing the signer
      * @param signer The address of the signer
      */
-    error TAPCollectorSignerAlreadyAuthorized(address authorizingPayer, address signer);
+    error GraphTallyCollectorSignerAlreadyAuthorized(address authorizingPayer, address signer);
 
     /**
      * Thrown when the signer proof deadline is invalid
      * @param proofDeadline The deadline for the proof provided by the signer
      * @param currentTimestamp The current timestamp
      */
-    error TAPCollectorInvalidSignerProofDeadline(uint256 proofDeadline, uint256 currentTimestamp);
+    error GraphTallyCollectorInvalidSignerProofDeadline(uint256 proofDeadline, uint256 currentTimestamp);
 
     /**
      * Thrown when the signer proof is invalid
      */
-    error TAPCollectorInvalidSignerProof();
+    error GraphTallyCollectorInvalidSignerProof();
 
     /**
      * Thrown when the signer is not authorized by the payer
      * @param payer The address of the payer
      * @param signer The address of the signer
      */
-    error TAPCollectorSignerNotAuthorizedByPayer(address payer, address signer);
+    error GraphTallyCollectorSignerNotAuthorizedByPayer(address payer, address signer);
 
     /**
      * Thrown when the attempting to revoke a signer that was already revoked
      * @param signer The address of the signer
      */
-    error TAPCollectorAuthorizationAlreadyRevoked(address payer, address signer);
+    error GraphTallyCollectorAuthorizationAlreadyRevoked(address payer, address signer);
 
     /**
      * Thrown when attempting to thaw a signer that is already thawing
      * @param signer The address of the signer
      * @param thawEndTimestamp The timestamp at which the thawing period ends
      */
-    error TAPCollectorSignerAlreadyThawing(address signer, uint256 thawEndTimestamp);
+    error GraphTallyCollectorSignerAlreadyThawing(address signer, uint256 thawEndTimestamp);
 
     /**
      * Thrown when the signer is not thawing
      * @param signer The address of the signer
      */
-    error TAPCollectorSignerNotThawing(address signer);
+    error GraphTallyCollectorSignerNotThawing(address signer);
 
     /**
      * Thrown when the signer is still thawing
      * @param currentTimestamp The current timestamp
      * @param thawEndTimestamp The timestamp at which the thawing period ends
      */
-    error TAPCollectorSignerStillThawing(uint256 currentTimestamp, uint256 thawEndTimestamp);
+    error GraphTallyCollectorSignerStillThawing(uint256 currentTimestamp, uint256 thawEndTimestamp);
 
     /**
      * Thrown when the RAV signer is invalid
      */
-    error TAPCollectorInvalidRAVSigner();
+    error GraphTallyCollectorInvalidRAVSigner();
 
     /**
      * Thrown when the RAV payer does not match the signers authorized payer
      * @param authorizedPayer The address of the authorized payer
      * @param ravPayer The address of the RAV payer
      */
-    error TAPCollectorInvalidRAVPayer(address authorizedPayer, address ravPayer);
+    error GraphTallyCollectorInvalidRAVPayer(address authorizedPayer, address ravPayer);
 
     /**
      * Thrown when the RAV is for a data service the service provider has no provision for
      * @param dataService The address of the data service
      */
-    error TAPCollectorUnauthorizedDataService(address dataService);
+    error GraphTallyCollectorUnauthorizedDataService(address dataService);
 
     /**
      * Thrown when the caller is not the data service the RAV was issued to
      * @param caller The address of the caller
      * @param dataService The address of the data service
      */
-    error TAPCollectorCallerNotDataService(address caller, address dataService);
+    error GraphTallyCollectorCallerNotDataService(address caller, address dataService);
 
     /**
      * @notice Thrown when the tokens collected are inconsistent with the collection history
      * Each RAV should have a value greater than the previous one
      * @param tokens The amount of tokens in the RAV
      * @param tokensCollected The amount of tokens already collected
      */
-    error TAPCollectorInconsistentRAVTokens(uint256 tokens, uint256 tokensCollected);
+    error GraphTallyCollectorInconsistentRAVTokens(uint256 tokens, uint256 tokensCollected);
 
     /**
      * Thrown when the attempting to collect more tokens than what it's owed
      * @param tokensToCollect The amount of tokens to collect
      * @param maxTokensToCollect The maximum amount of tokens to collect
      */
-    error TAPCollectorInvalidTokensToCollectAmount(uint256 tokensToCollect, uint256 maxTokensToCollect);
+    error GraphTallyCollectorInvalidTokensToCollectAmount(uint256 tokensToCollect, uint256 maxTokensToCollect);
 
     /**
      * @notice Authorize a signer to sign on behalf of the payer.

packages/horizon/contracts/payments/collectors/TAPCollector.sol renamed to packages/horizon/contracts/payments/collectors/GraphTallyCollector.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.27;
 
 import { IGraphPayments } from "../../interfaces/IGraphPayments.sol";
-import { ITAPCollector } from "../../interfaces/ITAPCollector.sol";
+import { IGraphTallyCollector } from "../../interfaces/IGraphTallyCollector.sol";
 
 import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
 import { PPMMath } from "../../libraries/PPMMath.sol";
@@ -12,9 +12,9 @@ import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
 
 /**
- * @title TAPCollector contract
- * @dev Implements the {ITAPCollector} and {IPaymentCollector} interfaces.
- * @notice A payments collector contract that can be used to collect payments using a TAP RAV (Receipt Aggregate Voucher).
+ * @title GraphTallyCollector contract
+ * @dev Implements the {IGraphTallyCollector} and {IPaymentCollector} interfaces.
+ * @notice A payments collector contract that can be used to collect payments using a GraphTally RAV (Receipt Aggregate Voucher).
  * @dev Note that the contract expects the RAV aggregate value to be monotonically increasing, each successive RAV for the same
  * (data service-payer-receiver) tuple should have a value greater than the previous one. The contract will keep track of the tokens
  * already collected and calculate the difference to collect.
@@ -23,7 +23,7 @@ import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/Mes
  * @custom:security-contact Please email [email protected] if you find any
  * bugs. We may have an active bug bounty program.
  */
-contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
+contract GraphTallyCollector is EIP712, GraphDirectory, IGraphTallyCollector {
     using PPMMath for uint256;
 
     /// @notice The EIP712 typehash for the ReceiptAggregateVoucher struct
@@ -45,7 +45,7 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
     uint256 public immutable REVOKE_SIGNER_THAWING_PERIOD;
 
     /**
-     * @notice Constructs a new instance of the TAPVerifier contract.
+     * @notice Constructs a new instance of the GraphTallyCollector contract.
      * @param eip712Name The name of the EIP712 domain.
      * @param eip712Version The version of the EIP712 domain.
      * @param controller The address of the Graph controller.
@@ -61,12 +61,12 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
     }
 
     /**
-     * See {ITAPCollector.authorizeSigner}.
+     * See {IGraphTallyCollector.authorizeSigner}.
      */
     function authorizeSigner(address signer, uint256 proofDeadline, bytes calldata proof) external override {
         require(
             authorizedSigners[signer].payer == address(0),
-            TAPCollectorSignerAlreadyAuthorized(authorizedSigners[signer].payer, signer)
+            GraphTallyCollectorSignerAlreadyAuthorized(authorizedSigners[signer].payer, signer)
         );
 
         _verifyAuthorizedSignerProof(proof, proofDeadline, signer);
@@ -77,46 +77,46 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
     }
 
     /**
-     * See {ITAPCollector.thawSigner}.
+     * See {IGraphTallyCollector.thawSigner}.
      */
     function thawSigner(address signer) external override {
         PayerAuthorization storage authorization = authorizedSigners[signer];
 
-        require(authorization.payer == msg.sender, TAPCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
-        require(!authorization.revoked, TAPCollectorAuthorizationAlreadyRevoked(msg.sender, signer));
+        require(authorization.payer == msg.sender, GraphTallyCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
+        require(!authorization.revoked, GraphTallyCollectorAuthorizationAlreadyRevoked(msg.sender, signer));
         require(
             authorization.thawEndTimestamp == 0,
-            TAPCollectorSignerAlreadyThawing(signer, authorization.thawEndTimestamp)
+            GraphTallyCollectorSignerAlreadyThawing(signer, authorization.thawEndTimestamp)
         );
 
         authorization.thawEndTimestamp = block.timestamp + REVOKE_SIGNER_THAWING_PERIOD;
         emit SignerThawing(msg.sender, signer, authorization.thawEndTimestamp);
     }
 
     /**
-     * See {ITAPCollector.cancelThawSigner}.
+     * See {IGraphTallyCollector.cancelThawSigner}.
      */
     function cancelThawSigner(address signer) external override {
         PayerAuthorization storage authorization = authorizedSigners[signer];
 
-        require(authorization.payer == msg.sender, TAPCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
-        require(authorization.thawEndTimestamp > 0, TAPCollectorSignerNotThawing(signer));
+        require(authorization.payer == msg.sender, GraphTallyCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
+        require(authorization.thawEndTimestamp > 0, GraphTallyCollectorSignerNotThawing(signer));
 
         authorization.thawEndTimestamp = 0;
         emit SignerThawCanceled(msg.sender, signer, 0);
     }
 
     /**
-     * See {ITAPCollector.revokeAuthorizedSigner}.
+     * See {IGraphTallyCollector.revokeAuthorizedSigner}.
      */
     function revokeAuthorizedSigner(address signer) external override {
         PayerAuthorization storage authorization = authorizedSigners[signer];
 
-        require(authorization.payer == msg.sender, TAPCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
-        require(authorization.thawEndTimestamp > 0, TAPCollectorSignerNotThawing(signer));
+        require(authorization.payer == msg.sender, GraphTallyCollectorSignerNotAuthorizedByPayer(msg.sender, signer));
+        require(authorization.thawEndTimestamp > 0, GraphTallyCollectorSignerNotThawing(signer));
         require(
             authorization.thawEndTimestamp <= block.timestamp,
-            TAPCollectorSignerStillThawing(block.timestamp, authorization.thawEndTimestamp)
+            GraphTallyCollectorSignerStillThawing(block.timestamp, authorization.thawEndTimestamp)
         );
 
         authorization.revoked = true;
@@ -145,21 +145,21 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
     }
 
     /**
-     * @notice See {ITAPCollector.recoverRAVSigner}
+     * @notice See {IGraphTallyCollector.recoverRAVSigner}
      */
     function recoverRAVSigner(SignedRAV calldata signedRAV) external view override returns (address) {
         return _recoverRAVSigner(signedRAV);
     }
 
     /**
-     * @notice See {ITAPCollector.encodeRAV}
+     * @notice See {IGraphTallyCollector.encodeRAV}
      */
     function encodeRAV(ReceiptAggregateVoucher calldata rav) external view returns (bytes32) {
         return _encodeRAV(rav);
     }
 
     /**
-     * @notice See {ITAPCollector.collect}
+     * @notice See {IGraphTallyCollector.collect}
      */
     function _collect(
         IGraphPayments.PaymentTypes _paymentType,
@@ -171,19 +171,19 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
         // Ensure caller is the RAV data service
         require(
             signedRAV.rav.dataService == msg.sender,
-            TAPCollectorCallerNotDataService(msg.sender, signedRAV.rav.dataService)
+            GraphTallyCollectorCallerNotDataService(msg.sender, signedRAV.rav.dataService)
         );
 
         // Ensure RAV signer is authorized for a payer
         address signer = _recoverRAVSigner(signedRAV);
         require(
             authorizedSigners[signer].payer != address(0) && !authorizedSigners[signer].revoked,
-            TAPCollectorInvalidRAVSigner()
+            GraphTallyCollectorInvalidRAVSigner()
         );
 
         // Ensure RAV payer matches the authorized payer
         address payer = authorizedSigners[signer].payer;
-        require(signedRAV.rav.payer == payer, TAPCollectorInvalidRAVPayer(payer, signedRAV.rav.payer));
+        require(signedRAV.rav.payer == payer, GraphTallyCollectorInvalidRAVPayer(payer, signedRAV.rav.payer));
 
         bytes32 collectionId = signedRAV.rav.collectionId;
         address dataService = signedRAV.rav.dataService;
@@ -197,7 +197,7 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
                 signedRAV.rav.serviceProvider,
                 signedRAV.rav.dataService
             );
-            require(tokensAvailable > 0, TAPCollectorUnauthorizedDataService(signedRAV.rav.dataService));
+            require(tokensAvailable > 0, GraphTallyCollectorUnauthorizedDataService(signedRAV.rav.dataService));
         }
 
         uint256 tokensToCollect = 0;
@@ -206,15 +206,18 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
             uint256 tokensAlreadyCollected = tokensCollected[dataService][collectionId][receiver][payer];
             require(
                 tokensRAV > tokensAlreadyCollected,
-                TAPCollectorInconsistentRAVTokens(tokensRAV, tokensAlreadyCollected)
+                GraphTallyCollectorInconsistentRAVTokens(tokensRAV, tokensAlreadyCollected)
             );
 
             if (_tokensToCollect == 0) {
                 tokensToCollect = tokensRAV - tokensAlreadyCollected;
             } else {
                 require(
                     _tokensToCollect <= tokensRAV - tokensAlreadyCollected,
-                    TAPCollectorInvalidTokensToCollectAmount(_tokensToCollect, tokensRAV - tokensAlreadyCollected)
+                    GraphTallyCollectorInvalidTokensToCollectAmount(
+                        _tokensToCollect,
+                        tokensRAV - tokensAlreadyCollected
+                    )
                 );
                 tokensToCollect = _tokensToCollect;
             }
@@ -243,15 +246,15 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
     }
 
     /**
-     * @notice See {ITAPCollector.recoverRAVSigner}
+     * @notice See {IGraphTallyCollector.recoverRAVSigner}
      */
     function _recoverRAVSigner(SignedRAV memory _signedRAV) private view returns (address) {
         bytes32 messageHash = _encodeRAV(_signedRAV.rav);
         return ECDSA.recover(messageHash, _signedRAV.signature);
     }
 
     /**
-     * @notice See {ITAPCollector.encodeRAV}
+     * @notice See {IGraphTallyCollector.encodeRAV}
      */
     function _encodeRAV(ReceiptAggregateVoucher memory _rav) private view returns (bytes32) {
         return
@@ -280,7 +283,7 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
         // Verify that the proofDeadline has not passed
         require(
             _proofDeadline > block.timestamp,
-            TAPCollectorInvalidSignerProofDeadline(_proofDeadline, block.timestamp)
+            GraphTallyCollectorInvalidSignerProofDeadline(_proofDeadline, block.timestamp)
         );
 
         // Generate the hash of the payer's address
@@ -290,6 +293,6 @@ contract TAPCollector is EIP712, GraphDirectory, ITAPCollector {
         bytes32 digest = MessageHashUtils.toEthSignedMessageHash(messageHash);
 
         // Verify that the recovered signer matches the expected signer
-        require(ECDSA.recover(digest, _proof) == _signer, TAPCollectorInvalidSignerProof());
+        require(ECDSA.recover(digest, _proof) == _signer, GraphTallyCollectorInvalidSignerProof());
     }
 }

packages/horizon/ignition/configs/horizon-migrate.default.json5

@@ -25,8 +25,8 @@
   "PaymentsEscrow": {
     "withdrawEscrowThawingPeriod": 10000
   },
-  "TAPCollector": {
-    "eip712Name": "TAPCollector",
+  "GraphTallyCollector": {
+    "eip712Name": "GraphTallyCollector",
     "eip712Version": "1",
     "revokeSignerThawingPeriod": 10000
   },

packages/horizon/ignition/configs/horizon-migrate.horizon-virtualArbitrumOne.json5

@@ -25,8 +25,8 @@
   "PaymentsEscrow": {
     "withdrawEscrowThawingPeriod": 10000
   },
-  "TAPCollector": {
-    "eip712Name": "TAPCollector",
+  "GraphTallyCollector": {
+    "eip712Name": "GraphTallyCollector",
     "eip712Version": "1",
     "revokeSignerThawingPeriod": 10000
   },

packages/horizon/ignition/configs/horizon.default.json5

@@ -28,8 +28,8 @@
   "PaymentsEscrow": {
     "withdrawEscrowThawingPeriod": 10000
   },
-  "TAPCollector": {
-    "eip712Name": "TAPCollector",
+  "GraphTallyCollector": {
+    "eip712Name": "GraphTallyCollector",
     "eip712Version": "1",
     "revokeSignerThawingPeriod": 10000
   }