Skip to content

Commit 6d85f96

Browse files
sammccordsammccord
authored
[BOOST-4506] feat(evm): signature based incentives (#37)
2 parents c0e0640 + b40c8b0 commit 6d85f96

File tree

2 files changed

+297
-0
lines changed

2 files changed

+297
-0
lines changed

‎packages/evm/contracts/incentives/ERC20VariableIncentive.sol

+138
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,138 @@
1+
// SPDX-License-Identifier: GPL-3.0
2+
pragma solidity ^0.8.24;
3+
4+
import {LibPRNG} from "@solady/utils/LibPRNG.sol";
5+
import {SafeTransferLib} from "@solady/utils/SafeTransferLib.sol";
6+
7+
import {BoostError} from "contracts/shared/BoostError.sol";
8+
import {Incentive} from "contracts/incentives/Incentive.sol";
9+
import {Budget} from "contracts/budgets/Budget.sol";
10+
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
11+
/// @title ERC20 Incentive with Variable Rewards
12+
/// @notice A modified ERC20 incentive implementation that allows claiming of variable token amounts with a spending limit
13+
14+
contract ERC20VariableIncentive is Incentive {
15+
using SafeTransferLib for address;
16+
17+
/// @notice The reward multiplier; if 0, the signed amount from the claim payload is used directly
18+
/// @notice The payload for initializing the incentive
19+
struct InitPayload {
20+
address asset;
21+
uint256 reward;
22+
uint256 limit;
23+
}
24+
25+
/// @notice The address of the ERC20-like token
26+
address public asset;
27+
28+
/// @notice The spending limit (max total claimable amount)
29+
uint256 public limit;
30+
31+
/// @notice The total amount claimed so far
32+
uint256 public totalClaimed;
33+
34+
/// @notice Initialize the contract with the incentive parameters
35+
/// @param data_ The compressed incentive parameters `(address asset, uint256 reward, uint256 limit)`
36+
function initialize(bytes calldata data_) public override initializer {
37+
InitPayload memory init_ = abi.decode(data_, (InitPayload));
38+
39+
address asset_ = init_.asset;
40+
uint256 reward_ = init_.reward;
41+
uint256 limit_ = init_.limit;
42+
43+
if (limit_ == 0) revert BoostError.InvalidInitialization();
44+
45+
uint256 available = asset_.balanceOf(address(this));
46+
if (available < limit_) {
47+
revert BoostError.InsufficientFunds(init_.asset, available, limit_);
48+
}
49+
50+
asset = asset_;
51+
reward = reward_;
52+
limit = limit_;
53+
totalClaimed = 0;
54+
55+
_initializeOwner(msg.sender);
56+
}
57+
58+
/// @notice Claim the incentive with variable rewards
59+
/// @param data_ The data payload for the incentive claim `(address recipient, bytes data)`
60+
/// @return True if the incentive was successfully claimed
61+
function claim(bytes calldata data_) external override onlyOwner returns (bool) {
62+
ClaimPayload memory claim_ = abi.decode(data_, (ClaimPayload));
63+
uint256 signedAmount = abi.decode(claim_.data, (uint256));
64+
uint256 claimAmount;
65+
if (!_isClaimable(claim_.target)) revert NotClaimable();
66+
67+
if (reward == 0) {
68+
claimAmount = signedAmount;
69+
} else {
70+
// NOTE: this is assuming that the signed scalar is in ETH decimal format
71+
claimAmount = reward * signedAmount / 1e18;
72+
}
73+
74+
if (totalClaimed + claimAmount > limit) revert ClaimFailed();
75+
76+
totalClaimed += claimAmount;
77+
asset.safeTransfer(claim_.target, claimAmount);
78+
79+
emit Claimed(claim_.target, abi.encodePacked(asset, claim_.target, claimAmount));
80+
return true;
81+
}
82+
83+
/// @notice Check if an incentive is claimable
84+
/// @param data_ The data payload for the claim check `(address recipient, bytes data)`
85+
/// @return True if the incentive is claimable based on the data payload
86+
function isClaimable(bytes calldata data_) public view override returns (bool) {
87+
ClaimPayload memory claim_ = abi.decode(data_, (ClaimPayload));
88+
return _isClaimable(claim_.target);
89+
}
90+
91+
/// @notice Check if an incentive is claimable for a specific recipient
92+
/// @param recipient_ The address of the recipient
93+
/// @return True if the incentive is claimable for the recipient
94+
function _isClaimable(address recipient_) internal view returns (bool) {
95+
return totalClaimed < limit;
96+
}
97+
98+
/// @inheritdoc Incentive
99+
function reclaim(bytes calldata data_) external override onlyOwner returns (bool) {
100+
ClaimPayload memory claim_ = abi.decode(data_, (ClaimPayload));
101+
(uint256 amount) = abi.decode(claim_.data, (uint256));
102+
103+
limit -= amount;
104+
105+
// Transfer the tokens back to the intended recipient
106+
asset.safeTransfer(claim_.target, amount);
107+
emit Claimed(claim_.target, abi.encodePacked(asset, claim_.target, amount));
108+
109+
return true;
110+
}
111+
112+
/// @inheritdoc Incentive
113+
/// @notice Preflight the incentive to determine the required budget action
114+
/// @param data_ The data payload for the incentive `(address asset, uint256 reward, uint256 limit)`
115+
/// @return budgetData The {Transfer} payload to be passed to the {Budget} for interpretation
116+
function preflight(bytes calldata data_) external view override returns (bytes memory budgetData) {
117+
(address asset_, uint256 reward_, uint256 limit_) = abi.decode(data_, (address, uint256, uint256));
118+
119+
return abi.encode(
120+
Budget.Transfer({
121+
assetType: Budget.AssetType.ERC20,
122+
asset: asset_,
123+
target: address(this),
124+
data: abi.encode(Budget.FungiblePayload({amount: limit_}))
125+
})
126+
);
127+
}
128+
129+
/// @inheritdoc Incentive
130+
function getComponentInterface() public pure virtual override returns (bytes4) {
131+
return type(Incentive).interfaceId;
132+
}
133+
134+
/// @inheritdoc Incentive
135+
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
136+
return interfaceId == type(Incentive).interfaceId || super.supportsInterface(interfaceId);
137+
}
138+
}

‎packages/evm/test/incentives/ERC20VariableIncentive.t.sol

+159
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,159 @@
1+
// SPDX-License-Identifier: GPL-3.0
2+
pragma solidity ^0.8.24;
3+
4+
import {Test, console} from "lib/forge-std/src/Test.sol";
5+
import {MockERC20} from "contracts/shared/Mocks.sol";
6+
import {LibClone} from "@solady/utils/LibClone.sol";
7+
import {SafeTransferLib} from "@solady/utils/SafeTransferLib.sol";
8+
9+
import {BoostError} from "contracts/shared/BoostError.sol";
10+
import {Incentive} from "contracts/incentives/Incentive.sol";
11+
import {ERC20VariableIncentive} from "contracts/incentives/ERC20VariableIncentive.sol";
12+
13+
import {Budget} from "contracts/budgets/Budget.sol";
14+
import {SimpleBudget} from "contracts/budgets/SimpleBudget.sol";
15+
16+
contract ERC20VariableIncentiveTest is Test {
17+
using SafeTransferLib for address;
18+
19+
// Declare test accounts as constants
20+
address CLAIM_RECIPIENT = makeAddr("CLAIM_RECIPIENT");
21+
address EXCEEDS_LIMIT_CLAIM = makeAddr("EXCEEDS_LIMIT_CLAIM");
22+
address VARIABLE_REWARD_CLAIM = makeAddr("VARIABLE_REWARD_CLAIM");
23+
24+
ERC20VariableIncentive public incentive;
25+
SimpleBudget public budget = new SimpleBudget();
26+
MockERC20 public mockAsset = new MockERC20();
27+
28+
function setUp() public {
29+
incentive = _newIncentiveClone();
30+
31+
// Preload the budget with some mock tokens
32+
mockAsset.mint(address(this), 100 ether);
33+
mockAsset.approve(address(budget), 100 ether);
34+
budget.allocate(_makeFungibleTransfer(Budget.AssetType.ERC20, address(mockAsset), address(this), 100 ether));
35+
36+
// Manually handle the budget disbursement
37+
budget.disburse(
38+
_makeFungibleTransfer(Budget.AssetType.ERC20, address(mockAsset), address(incentive), 100 ether)
39+
);
40+
}
41+
42+
///////////////////////////////
43+
// ERC20VariableIncentive.initialize //
44+
///////////////////////////////
45+
46+
function testInitialize() public {
47+
// Initialize the ERC20VariableIncentive
48+
_initialize(address(mockAsset), 1 ether, 5 ether);
49+
50+
// Check the incentive parameters
51+
assertEq(incentive.asset(), address(mockAsset));
52+
assertEq(incentive.reward(), 1 ether);
53+
assertEq(incentive.limit(), 5 ether);
54+
}
55+
56+
function testInitialize_InsufficientFunds() public {
57+
// Attempt to initialize with a limit greater than available balance => revert
58+
vm.expectRevert(
59+
abi.encodeWithSelector(BoostError.InsufficientFunds.selector, address(mockAsset), 100 ether, 101 ether)
60+
);
61+
_initialize(address(mockAsset), 1 ether, 101 ether);
62+
}
63+
64+
function testInitialize_InvalidInitialization() public {
65+
// Attempt to initialize with invalid parameters => revert
66+
vm.expectRevert(BoostError.InvalidInitialization.selector);
67+
_initialize(address(mockAsset), 0, 0);
68+
}
69+
70+
////////////////////////////////
71+
// ERC20VariableIncentive.claim //
72+
////////////////////////////////
73+
74+
function testClaim() public {
75+
// Initialize the ERC20VariableIncentive
76+
_initialize(address(mockAsset), 1 ether, 5 ether);
77+
78+
vm.expectEmit(true, false, false, true);
79+
emit Incentive.Claimed(CLAIM_RECIPIENT, abi.encodePacked(address(mockAsset), CLAIM_RECIPIENT, uint256(1 ether)));
80+
81+
// Claim the incentive
82+
bytes memory claimPayload =
83+
abi.encode(Incentive.ClaimPayload({target: CLAIM_RECIPIENT, data: abi.encode(1 ether)}));
84+
incentive.claim(claimPayload);
85+
86+
// Check the claim status and balance
87+
assertEq(mockAsset.balanceOf(CLAIM_RECIPIENT), 1 ether);
88+
assertTrue(incentive.isClaimable(claimPayload));
89+
}
90+
91+
function testClaim_ClaimFailed() public {
92+
// Initialize the ERC20VariableIncentive
93+
_initialize(address(mockAsset), 1 ether, 2 ether);
94+
95+
// Attempt to claim more than the limit => revert
96+
bytes memory claimPayload =
97+
abi.encode(Incentive.ClaimPayload({target: EXCEEDS_LIMIT_CLAIM, data: abi.encode(3 ether)}));
98+
vm.expectRevert(Incentive.ClaimFailed.selector);
99+
incentive.claim(claimPayload);
100+
}
101+
102+
function testClaim_VariableReward() public {
103+
// Initialize the ERC20VariableIncentive with zero reward, meaning signed amount will be used directly
104+
_initialize(address(mockAsset), 0, 5 ether);
105+
106+
// Claim with variable reward
107+
bytes memory claimPayload =
108+
abi.encode(Incentive.ClaimPayload({target: VARIABLE_REWARD_CLAIM, data: abi.encode(2 ether)}));
109+
incentive.claim(claimPayload);
110+
111+
// Check the claim status and balance
112+
assertEq(mockAsset.balanceOf(VARIABLE_REWARD_CLAIM), 2 ether);
113+
assertTrue(incentive.isClaimable(claimPayload));
114+
}
115+
116+
/////////////////////////////////
117+
// ERC20VariableIncentive.supportsInterface //
118+
/////////////////////////////////
119+
120+
function testSupportsInterface() public {
121+
// Ensure the contract supports the Incentive interface
122+
assertTrue(incentive.supportsInterface(type(Incentive).interfaceId));
123+
}
124+
125+
function testSupportsInterface_NotSupported() public {
126+
// Ensure the contract does not support an unsupported interface
127+
assertFalse(incentive.supportsInterface(type(Test).interfaceId));
128+
}
129+
130+
///////////////////////////
131+
// Test Helper Functions //
132+
///////////////////////////
133+
134+
function _newIncentiveClone() internal returns (ERC20VariableIncentive) {
135+
return ERC20VariableIncentive(LibClone.clone(address(new ERC20VariableIncentive())));
136+
}
137+
138+
function _initialize(address asset, uint256 reward, uint256 limit) internal {
139+
incentive.initialize(_initPayload(asset, reward, limit));
140+
}
141+
142+
function _initPayload(address asset, uint256 reward, uint256 limit) internal pure returns (bytes memory) {
143+
return abi.encode(ERC20VariableIncentive.InitPayload({asset: asset, reward: reward, limit: limit}));
144+
}
145+
146+
function _makeFungibleTransfer(Budget.AssetType assetType, address asset, address target, uint256 value)
147+
internal
148+
pure
149+
returns (bytes memory)
150+
{
151+
Budget.Transfer memory transfer;
152+
transfer.assetType = assetType;
153+
transfer.asset = asset;
154+
transfer.target = target;
155+
transfer.data = abi.encode(Budget.FungiblePayload({amount: value}));
156+
157+
return abi.encode(transfer);
158+
}
159+
}

0 commit comments

Comments
 (0)