f: switch to uint64 timestamps

matiasedgeandnode · matiasedgeandnode · commit 99ca09c69e2a · 2025-05-13T14:20:30.000-03:00
diff --git a/IndexingPaymentsTodo.md b/IndexingPaymentsTodo.md
@@ -1,19 +1,15 @@
 # Still pending
 
 * Arbitration Charter: Update to support disputing IndexingFee.
-* Expose a function that indexers can use to calculate the tokens to be collected and other collection params?
-* test_SubgraphService_CollectIndexingFee_Integration fails with PaymentsEscrowInconsistentCollection
-* Switch timestamps to uint64.
-* Check that UUID-v4 fits in `bytes16`
 * Check code coverage
 * Check contract size
-* Add upgrade path to v2 collector terms
-* It's more like a collect + cancel since the indexer is expected to stop work then and there. When posting a POI that's < N-1 epoch. Answer: Emit signal that the collection is meant to be final.
 * Don't love cancel agreement on stop service / close stale allocation.
-* Place all agreement terms into one struct
 
 # Done
 
+* DONE: ~~Switch cancel event in recurring collector to use Enum~~
+* DONE: ~~Switch timestamps to uint64~~
+* DONE: ~~Check that UUID-v4 fits in `bytes16`~~
 * DONE: ~~Double check cancelation policy. Who can cancel when? Right now is either party at any time. Answer: If gateway cancels allow collection till that point.~~
 * DONE: ~~If an indexer closes an allocation, what should happen to the accepeted agreement? Answer: Look into canceling agreement as part of stop service.~~
 * DONE: ~~Switch `duration` for `endsAt`? Answer: Do it.~~
@@ -39,3 +35,10 @@
 * DONE: ~~Unify to one error in Decoder.sol~~
 * DONE: ~~Built-in upgrade path to indexing agreements v2~~
 * DONE: ~~Missing events for accept, cancel, upgrade RCAs.~~
+
+# Won't Fix
+
+* Add upgrade path to v2 collector terms
+* Expose a function that indexers can use to calculate the tokens to be collected and other collection params?
+* Place all agreement terms into one struct
+* It's more like a collect + cancel since the indexer is expected to stop work then and there. When posting a POI that's < N-1 epoch. Answer: Emit signal that the collection is meant to be final. Counter: Won't do since collector can't signal back to data service that payment is maxed out. Could emit an event from the collector, but is it really worth it? Right now any collection where epoch POI < current POI is suspect.
diff --git a/packages/horizon/contracts/interfaces/IRecurringCollector.sol b/packages/horizon/contracts/interfaces/IRecurringCollector.sol
@@ -38,9 +38,9 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         // The agreement ID of the RCA
         bytes16 agreementId;
         // The deadline for accepting the RCA
-        uint256 deadline;
+        uint64 deadline;
         // The timestamp when the agreement ends
-        uint256 endsAt;
+        uint64 endsAt;
         // The address of the payer the RCA was issued by
         address payer;
         // The address of the data service the RCA was issued to
@@ -73,9 +73,9 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         // The agreement ID
         bytes16 agreementId;
         // The deadline for upgrading
-        uint256 deadline;
+        uint64 deadline;
         // The timestamp when the agreement ends
-        uint256 endsAt;
+        uint64 endsAt;
         // The maximum amount of tokens that can be collected in the first collection
         // on top of the amount allowed for subsequent collections
         uint256 maxInitialTokens;
@@ -99,11 +99,11 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         // The address of the service provider
         address serviceProvider;
         // The timestamp when the agreement was accepted
-        uint256 acceptedAt;
+        uint64 acceptedAt;
         // The timestamp when the agreement was last collected at
-        uint256 lastCollectionAt;
+        uint64 lastCollectionAt;
         // The timestamp when the agreement ends
-        uint256 endsAt;
+        uint64 endsAt;
         // The maximum amount of tokens that can be collected in the first collection
         // on top of the amount allowed for subsequent collections
         uint256 maxInitialTokens;
@@ -115,7 +115,7 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         // The maximum amount of seconds that can pass between collections
         uint32 maxSecondsPerCollection;
         // The timestamp when the agreement was canceled
-        uint256 canceledAt;
+        uint64 canceledAt;
         // The state of the agreement
         AgreementState state;
     }
@@ -149,8 +149,8 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         address indexed payer,
         address indexed serviceProvider,
         bytes16 agreementId,
-        uint256 acceptedAt,
-        uint256 endsAt,
+        uint64 acceptedAt,
+        uint64 endsAt,
         uint256 maxInitialTokens,
         uint256 maxOngoingTokensPerSecond,
         uint32 minSecondsPerCollection,
@@ -162,14 +162,17 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
      * @param dataService The address of the data service
      * @param payer The address of the payer
      * @param serviceProvider The address of the service provider
+     * @param agreementId The agreement ID
+     * @param canceledAt The timestamp when the agreement was canceled
+     * @param canceledBy The party that canceled the agreement
      */
     event AgreementCanceled(
         address indexed dataService,
         address indexed payer,
         address indexed serviceProvider,
         bytes16 agreementId,
-        uint256 canceledAt,
-        address canceledBy
+        uint64 canceledAt,
+        CancelAgreementBy canceledBy
     );
 
     /**
@@ -190,8 +193,8 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
         address indexed payer,
         address indexed serviceProvider,
         bytes16 agreementId,
-        uint256 upgradedAt,
-        uint256 endsAt,
+        uint64 upgradedAt,
+        uint64 endsAt,
         uint256 maxInitialTokens,
         uint256 maxOngoingTokensPerSecond,
         uint32 minSecondsPerCollection,
@@ -228,9 +231,9 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
 
     /**
      * Thrown when interacting with an agreement with an elapsed deadline
-     * @param elapsedAt The timestamp when the deadline elapsed
+     * @param deadline The elapsed deadline timestamp
      */
-    error RecurringCollectorAgreementDeadlineElapsed(uint256 elapsedAt);
+    error RecurringCollectorAgreementDeadlineElapsed(uint64 deadline);
 
     /**
      * Thrown when the signer is invalid
@@ -273,23 +276,23 @@ interface IRecurringCollector is IAuthorizable, IPaymentsCollector {
      * @param agreementId The agreement ID
      * @param endsAt The agreement end timestamp
      */
-    error RecurringCollectorAgreementElapsed(bytes16 agreementId, uint256 endsAt);
+    error RecurringCollectorAgreementElapsed(bytes16 agreementId, uint64 endsAt);
 
     /**
      * Thrown when calling collect() too soon
      * @param agreementId The agreement ID
      * @param secondsSinceLast Seconds since last collection
      * @param minSeconds Minimum seconds between collections
      */
-    error RecurringCollectorCollectionTooSoon(bytes16 agreementId, uint256 secondsSinceLast, uint256 minSeconds);
+    error RecurringCollectorCollectionTooSoon(bytes16 agreementId, uint32 secondsSinceLast, uint32 minSeconds);
 
     /**
      * Thrown when calling collect() too late
      * @param agreementId The agreement ID
      * @param secondsSinceLast Seconds since last collection
      * @param maxSeconds Maximum seconds between collections
      */
-    error RecurringCollectorCollectionTooLate(bytes16 agreementId, uint256 secondsSinceLast, uint256 maxSeconds);
+    error RecurringCollectorCollectionTooLate(bytes16 agreementId, uint64 secondsSinceLast, uint32 maxSeconds);
 
     /**
      * @dev Accept an indexing agreement.
diff --git a/packages/horizon/contracts/payments/collectors/RecurringCollector.sol b/packages/horizon/contracts/payments/collectors/RecurringCollector.sol
@@ -94,7 +94,7 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
         );
 
         // accept the agreement
-        agreement.acceptedAt = block.timestamp;
+        agreement.acceptedAt = uint64(block.timestamp);
         agreement.state = AgreementState.Accepted;
         agreement.dataService = signedRCA.rca.dataService;
         agreement.payer = signedRCA.rca.payer;
@@ -135,25 +135,18 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
             agreement.dataService == msg.sender,
             RecurringCollectorDataServiceNotAuthorized(agreementId, msg.sender)
         );
-        agreement.canceledAt = block.timestamp;
-        address canceledBy;
-        if (by == CancelAgreementBy.Payer) {
-            agreement.state = AgreementState.CanceledByPayer;
-            canceledBy = agreement.payer;
-        } else if (by == CancelAgreementBy.ServiceProvider) {
-            agreement.state = AgreementState.CanceledByServiceProvider;
-            canceledBy = agreement.serviceProvider;
-        } else {
-            revert("invalid CancelAgreementBy");
-        }
+        agreement.canceledAt = uint64(block.timestamp);
+        agreement.state = by == CancelAgreementBy.Payer
+            ? AgreementState.CanceledByPayer
+            : AgreementState.CanceledByServiceProvider;
 
         emit AgreementCanceled(
             agreement.dataService,
             agreement.payer,
             agreement.serviceProvider,
             agreementId,
-            block.timestamp,
-            canceledBy
+            agreement.canceledAt,
+            by
         );
     }
 
@@ -194,7 +187,7 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
             agreement.payer,
             agreement.serviceProvider,
             signedRCAU.rcau.agreementId,
-            block.timestamp,
+            uint64(block.timestamp),
             agreement.endsAt,
             agreement.maxInitialTokens,
             agreement.maxOngoingTokensPerSecond,
@@ -284,7 +277,7 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
                 _params.dataServiceCut
             );
         }
-        agreement.lastCollectionAt = block.timestamp;
+        agreement.lastCollectionAt = uint64(block.timestamp);
 
         emit PaymentCollected(
             IGraphPayments.PaymentTypes.IndexingFee,
@@ -350,11 +343,19 @@ contract RecurringCollector is EIP712, GraphDirectory, Authorizable, IRecurringC
         collectionSeconds -= _agreementCollectionStartAt(_agreement);
         require(
             collectionSeconds >= _agreement.minSecondsPerCollection,
-            RecurringCollectorCollectionTooSoon(_agreementId, collectionSeconds, _agreement.minSecondsPerCollection)
+            RecurringCollectorCollectionTooSoon(
+                _agreementId,
+                uint32(collectionSeconds),
+                _agreement.minSecondsPerCollection
+            )
         );
         require(
             collectionSeconds <= _agreement.maxSecondsPerCollection,
-            RecurringCollectorCollectionTooLate(_agreementId, collectionSeconds, _agreement.maxSecondsPerCollection)
+            RecurringCollectorCollectionTooLate(
+                _agreementId,
+                uint64(collectionSeconds),
+                _agreement.maxSecondsPerCollection
+            )
         );
 
         uint256 maxTokens = _agreement.maxOngoingTokensPerSecond * collectionSeconds;
diff --git a/packages/horizon/test/payments/recurring-collector/RecurringCollectorHelper.t.sol b/packages/horizon/test/payments/recurring-collector/RecurringCollectorHelper.t.sol
@@ -49,14 +49,16 @@ contract RecurringCollectorHelper is AuthorizableHelper, Bounder {
         IRecurringCollector.RecurringCollectionAgreement memory rca
     ) public view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
         require(block.timestamp > 0, "block.timestamp can't be zero");
-        rca.deadline = bound(rca.deadline, 0, block.timestamp - 1);
+        require(block.timestamp <= type(uint64).max, "block.timestamp can't be huge");
+        rca.deadline = uint64(bound(rca.deadline, 0, block.timestamp - 1));
         return rca;
     }
 
     function withOKAcceptDeadline(
         IRecurringCollector.RecurringCollectionAgreement memory rca
     ) public view returns (IRecurringCollector.RecurringCollectionAgreement memory) {
-        rca.deadline = boundTimestampMin(rca.deadline, block.timestamp);
+        require(block.timestamp <= type(uint64).max, "block.timestamp can't be huge");
+        rca.deadline = uint64(boundTimestampMin(rca.deadline, block.timestamp));
         return rca;
     }
 
@@ -100,16 +102,18 @@ contract RecurringCollectorHelper is AuthorizableHelper, Bounder {
         return rcau;
     }
 
-    function _sensibleDeadline(uint256 _seed) internal view returns (uint256) {
-        return bound(_seed, block.timestamp + 1, block.timestamp + 7200); // between now and 2h
+    function _sensibleDeadline(uint256 _seed) internal view returns (uint64) {
+        return uint64(bound(_seed, block.timestamp + 1, block.timestamp + 7200)); // between now and 2h
     }
 
-    function _sensibleEndsAt(uint256 _seed, uint32 _maxSecondsPerCollection) internal view returns (uint256) {
+    function _sensibleEndsAt(uint256 _seed, uint32 _maxSecondsPerCollection) internal view returns (uint64) {
         return
-            bound(
-                _seed,
-                block.timestamp + (10 * uint256(_maxSecondsPerCollection)),
-                block.timestamp + (1_000_000 * uint256(_maxSecondsPerCollection))
+            uint64(
+                bound(
+                    _seed,
+                    block.timestamp + (10 * uint256(_maxSecondsPerCollection)),
+                    block.timestamp + (1_000_000 * uint256(_maxSecondsPerCollection))
+                )
             ); // between 10 and 1M max collections
     }
 
diff --git a/packages/horizon/test/payments/recurring-collector/accept.t.sol b/packages/horizon/test/payments/recurring-collector/accept.t.sol
@@ -21,7 +21,7 @@ contract RecurringCollectorAcceptTest is RecurringCollectorSharedTest {
         uint256 unboundedSkip
     ) public {
         vm.assume(fuzzySignedRCA.rca.agreementId != bytes16(0));
-        skip(boundSkipFloor(unboundedSkip, 1));
+        skip(boundSkip(unboundedSkip, 1, type(uint64).max - block.timestamp));
         fuzzySignedRCA.rca = _recurringCollectorHelper.withElapsedAcceptDeadline(fuzzySignedRCA.rca);
 
         bytes memory expectedErr = abi.encodeWithSelector(
diff --git a/packages/horizon/test/payments/recurring-collector/shared.t.sol b/packages/horizon/test/payments/recurring-collector/shared.t.sol
@@ -74,7 +74,7 @@ contract RecurringCollectorSharedTest is Test, Bounder {
             _signedRCA.rca.payer,
             _signedRCA.rca.serviceProvider,
             _signedRCA.rca.agreementId,
-            block.timestamp,
+            uint64(block.timestamp),
             _signedRCA.rca.endsAt,
             _signedRCA.rca.maxInitialTokens,
             _signedRCA.rca.maxOngoingTokensPerSecond,
@@ -95,8 +95,8 @@ contract RecurringCollectorSharedTest is Test, Bounder {
             _rca.payer,
             _rca.serviceProvider,
             _rca.agreementId,
-            block.timestamp,
-            _by == IRecurringCollector.CancelAgreementBy.Payer ? _rca.payer : _rca.serviceProvider
+            uint64(block.timestamp),
+            _by
         );
         vm.prank(_rca.dataService);
         _recurringCollector.cancel(_rca.agreementId, _by);
diff --git a/packages/horizon/test/payments/recurring-collector/upgrade.t.sol b/packages/horizon/test/payments/recurring-collector/upgrade.t.sol
@@ -21,8 +21,8 @@ contract RecurringCollectorUpgradeTest is RecurringCollectorSharedTest {
         rcau = _recurringCollectorHelper.sensibleRCAU(rcau);
         rcau.agreementId = rca.agreementId;
 
-        boundSkipCeil(unboundedUpgradeSkip, type(uint256).max);
-        rcau.deadline = bound(rcau.deadline, 0, block.timestamp - 1);
+        boundSkipCeil(unboundedUpgradeSkip, type(uint64).max);
+        rcau.deadline = uint64(bound(rcau.deadline, 0, block.timestamp - 1));
         IRecurringCollector.SignedRCAU memory signedRCAU = IRecurringCollector.SignedRCAU({
             rcau: rcau,
             signature: ""
@@ -45,7 +45,7 @@ contract RecurringCollectorUpgradeTest is RecurringCollectorSharedTest {
         rcau = _recurringCollectorHelper.sensibleRCAU(rcau);
         rcau.agreementId = rca.agreementId;
 
-        rcau.deadline = block.timestamp;
+        rcau.deadline = uint64(block.timestamp);
         IRecurringCollector.SignedRCAU memory signedRCAU = IRecurringCollector.SignedRCAU({
             rcau: rcau,
             signature: ""
@@ -134,7 +134,7 @@ contract RecurringCollectorUpgradeTest is RecurringCollectorSharedTest {
             accepted.rca.payer,
             accepted.rca.serviceProvider,
             rcau.agreementId,
-            block.timestamp,
+            uint64(block.timestamp),
             rcau.endsAt,
             rcau.maxInitialTokens,
             rcau.maxOngoingTokensPerSecond,
diff --git a/packages/subgraph-service/test/subgraphService/indexing-agreement/integration.t.sol b/packages/subgraph-service/test/subgraphService/indexing-agreement/integration.t.sol
