|
| 1 | +// SPDX-License-Identifier: MIT |
| 2 | +pragma solidity 0.8.27; |
| 3 | + |
| 4 | +import "forge-std/Test.sol"; |
| 5 | + |
| 6 | +import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; |
| 7 | +import { IHorizonStakingMain } from "../../contracts/interfaces/internal/IHorizonStakingMain.sol"; |
| 8 | +import { ITAPCollector } from "../../contracts/interfaces/ITAPCollector.sol"; |
| 9 | +import { IPaymentsCollector } from "../../contracts/interfaces/IPaymentsCollector.sol"; |
| 10 | +import { IGraphPayments } from "../../contracts/interfaces/IGraphPayments.sol"; |
| 11 | +import { TAPCollector } from "../../contracts/payments/collectors/TAPCollector.sol"; |
| 12 | +import { PPMMath } from "../../contracts/libraries/PPMMath.sol"; |
| 13 | + |
| 14 | +import { HorizonStakingSharedTest } from "../shared/horizon-staking/HorizonStakingShared.t.sol"; |
| 15 | +import { PaymentsEscrowSharedTest } from "../shared/payments-escrow/PaymentsEscrowShared.t.sol"; |
| 16 | + |
| 17 | +contract TAPCollectorTest is HorizonStakingSharedTest, PaymentsEscrowSharedTest { |
| 18 | + using PPMMath for uint256; |
| 19 | + |
| 20 | + address payer; |
| 21 | + uint256 payerPrivateKey; |
| 22 | + |
| 23 | + /* |
| 24 | + * HELPERS |
| 25 | + */ |
| 26 | + |
| 27 | + function _getQueryFeeEncodedData(address indexer, address collector, uint128 tokens) private view returns (bytes memory) { |
| 28 | + ITAPCollector.ReceiptAggregateVoucher memory rav = _getRAV(indexer, collector, tokens); |
| 29 | + bytes32 messageHash = tapCollector.encodeRAV(rav); |
| 30 | + (uint8 v, bytes32 r, bytes32 s) = vm.sign(payerPrivateKey, messageHash); |
| 31 | + bytes memory signature = abi.encodePacked(r, s, v); |
| 32 | + ITAPCollector.SignedRAV memory signedRAV = ITAPCollector.SignedRAV(rav, signature); |
| 33 | + return abi.encode(signedRAV); |
| 34 | + } |
| 35 | + |
| 36 | + function _getRAV( |
| 37 | + address indexer, |
| 38 | + address collector, |
| 39 | + uint128 tokens |
| 40 | + ) private pure returns (ITAPCollector.ReceiptAggregateVoucher memory rav) { |
| 41 | + return |
| 42 | + ITAPCollector.ReceiptAggregateVoucher({ |
| 43 | + dataService: collector, |
| 44 | + serviceProvider: indexer, |
| 45 | + timestampNs: 0, |
| 46 | + valueAggregate: tokens, |
| 47 | + metadata: abi.encode("") |
| 48 | + }); |
| 49 | + } |
| 50 | + |
| 51 | + function _collect(IGraphPayments.PaymentTypes _paymentType, bytes memory _data) private { |
| 52 | + (ITAPCollector.SignedRAV memory signedRAV, uint256 dataServiceCut) = abi.decode(_data, (ITAPCollector.SignedRAV, uint256)); |
| 53 | + bytes32 messageHash = tapCollector.encodeRAV(signedRAV.rav); |
| 54 | + address _payer = ECDSA.recover(messageHash, signedRAV.signature); |
| 55 | + uint256 tokensAlreadyCollected = tapCollector.tokensCollected(signedRAV.rav.dataService, signedRAV.rav.serviceProvider, _payer); |
| 56 | + uint256 tokensToCollect = signedRAV.rav.valueAggregate - tokensAlreadyCollected; |
| 57 | + uint256 tokensDataService = tokensToCollect.mulPPM(dataServiceCut); |
| 58 | + |
| 59 | + vm.expectEmit(address(tapCollector)); |
| 60 | + emit IPaymentsCollector.PaymentCollected( |
| 61 | + _paymentType, |
| 62 | + _payer, |
| 63 | + signedRAV.rav.serviceProvider, |
| 64 | + tokensToCollect, |
| 65 | + signedRAV.rav.dataService, |
| 66 | + tokensDataService |
| 67 | + ); |
| 68 | + emit ITAPCollector.RAVCollected( |
| 69 | + _payer, |
| 70 | + signedRAV.rav.dataService, |
| 71 | + signedRAV.rav.serviceProvider, |
| 72 | + signedRAV.rav.timestampNs, |
| 73 | + signedRAV.rav.valueAggregate, |
| 74 | + signedRAV.rav.metadata, |
| 75 | + signedRAV.signature |
| 76 | + ); |
| 77 | + |
| 78 | + uint256 tokensCollected = tapCollector.collect(_paymentType, _data); |
| 79 | + assertEq(tokensCollected, tokensToCollect); |
| 80 | + |
| 81 | + uint256 tokensCollectedAfter = tapCollector.tokensCollected(signedRAV.rav.dataService, signedRAV.rav.serviceProvider, _payer); |
| 82 | + assertEq(tokensCollectedAfter, signedRAV.rav.valueAggregate); |
| 83 | + } |
| 84 | + |
| 85 | + /* |
| 86 | + * SET UP |
| 87 | + */ |
| 88 | + |
| 89 | + function setUp() public virtual override { |
| 90 | + super.setUp(); |
| 91 | + (payer, payerPrivateKey) = makeAddrAndKey("payer"); |
| 92 | + vm.label({ account: payer, newLabel: "payer" }); |
| 93 | + deal({ token: address(token), to: payer, give: type(uint256).max }); |
| 94 | + } |
| 95 | + |
| 96 | + /* |
| 97 | + * TESTS |
| 98 | + */ |
| 99 | + |
| 100 | + function testCollect(uint256 tokens) public { |
| 101 | + tokens = bound(tokens, 1, type(uint128).max); |
| 102 | + |
| 103 | + resetPrank(payer); |
| 104 | + _approveCollector(address(tapCollector), tokens); |
| 105 | + _depositTokens(address(tapCollector), users.indexer, tokens); |
| 106 | + bytes memory data = _getQueryFeeEncodedData(users.indexer, users.verifier, uint128(tokens)); |
| 107 | + |
| 108 | + resetPrank(users.verifier); |
| 109 | + _collect(IGraphPayments.PaymentTypes.QueryFee, data); |
| 110 | + } |
| 111 | + |
| 112 | + function testCollect_Multiple(uint256 tokens, uint8 steps) public { |
| 113 | + steps = uint8(bound(steps, 1, 100)); |
| 114 | + tokens = bound(tokens, steps, type(uint128).max); |
| 115 | + |
| 116 | + resetPrank(payer); |
| 117 | + _approveCollector(address(tapCollector), tokens); |
| 118 | + _depositTokens(address(tapCollector), users.indexer, tokens); |
| 119 | + |
| 120 | + resetPrank(users.verifier); |
| 121 | + uint256 payed = 0; |
| 122 | + uint256 tokensPerStep = tokens / steps; |
| 123 | + for (uint256 i = 0; i < steps; i++) { |
| 124 | + bytes memory data = _getQueryFeeEncodedData(users.indexer, users.verifier, uint128(payed + tokensPerStep)); |
| 125 | + _collect(IGraphPayments.PaymentTypes.QueryFee, data); |
| 126 | + payed += tokensPerStep; |
| 127 | + } |
| 128 | + } |
| 129 | + |
| 130 | + function testCollect_RevertWhen_CallerNotDataService(uint256 tokens) public { |
| 131 | + tokens = bound(tokens, 1, type(uint128).max); |
| 132 | + |
| 133 | + resetPrank(payer); |
| 134 | + _approveCollector(address(tapCollector), tokens); |
| 135 | + _depositTokens(address(tapCollector), users.indexer, tokens); |
| 136 | + bytes memory data = _getQueryFeeEncodedData(users.indexer, users.verifier, uint128(tokens)); |
| 137 | + |
| 138 | + resetPrank(users.indexer); |
| 139 | + bytes memory expectedError = abi.encodeWithSelector( |
| 140 | + ITAPCollector.TAPCollectorCallerNotDataService.selector, |
| 141 | + users.indexer, |
| 142 | + users.verifier |
| 143 | + ); |
| 144 | + vm.expectRevert(expectedError); |
| 145 | + tapCollector.collect(IGraphPayments.PaymentTypes.QueryFee, data); |
| 146 | + } |
| 147 | + |
| 148 | + function testCollect_RevertWhen_InconsistentRAVTokens(uint256 tokens) public { |
| 149 | + tokens = bound(tokens, 1, type(uint128).max); |
| 150 | + |
| 151 | + resetPrank(payer); |
| 152 | + _approveCollector(address(tapCollector), tokens); |
| 153 | + _depositTokens(address(tapCollector), users.indexer, tokens); |
| 154 | + bytes memory data = _getQueryFeeEncodedData(users.indexer, users.verifier, uint128(tokens)); |
| 155 | + |
| 156 | + resetPrank(users.verifier); |
| 157 | + _collect(IGraphPayments.PaymentTypes.QueryFee, data); |
| 158 | + |
| 159 | + // Attempt to collect again |
| 160 | + vm.expectRevert(abi.encodeWithSelector( |
| 161 | + ITAPCollector.TAPCollectorInconsistentRAVTokens.selector, |
| 162 | + tokens, |
| 163 | + tokens |
| 164 | + )); |
| 165 | + tapCollector.collect(IGraphPayments.PaymentTypes.QueryFee, data); |
| 166 | + } |
| 167 | +} |
0 commit comments