编译器
0.8.19+commit.7dd6d404
文件 1 的 27：AccessControlModule.sol
pragma solidity ^0.8.17;
import { Sickle } from "contracts/Sickle.sol";
import { SickleFactory } from "contracts/SickleFactory.sol";
contract AccessControlModule {
SickleFactory public immutable factory;
error NotOwner(address sender);
error NotOwnerOrInternal();
error NotOwnerOrApproved();
error NotOwnerOrApprovedOrInternal();
error SickleNotDeployed();
error NotRegisteredSickle();
constructor(SickleFactory factory_) {
factory = factory_;
}
modifier onlyRegisteredSickle() {
if (factory.admins(address(this)) == address(0)) {
revert NotRegisteredSickle();
}
_;
}
modifier checkOwner(address sickleAddress) {
if (msg.sender != factory.admins(sickleAddress)) {
revert NotOwner(msg.sender);
}
_;
}
modifier checkOwnerOrApproved(address sickleAddress) {
Sickle sickle = Sickle(payable(sickleAddress));
if (factory.admins(sickleAddress) == address(0)) {
revert SickleNotDeployed();
}
if (!sickle.isOwnerOrApproved(msg.sender)) revert NotOwnerOrApproved();
_;
}
}
文件 2 的 27：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 3 的 27：Admin.sol
pragma solidity ^0.8.17;
abstract contract Admin {
error NotAdminError();
event AdminSet(address oldAdmin, address newAdmin);
address public admin;
modifier onlyAdmin() {
if (msg.sender != admin) revert NotAdminError();
_;
}
constructor(address admin_) {
emit AdminSet(admin, admin_);
admin = admin_;
}
function setAdmin(address newAdmin) external onlyAdmin {
emit AdminSet(admin, newAdmin);
admin = newAdmin;
}
}
文件 4 的 27：Clones.sol
pragma solidity ^0.8.0;
library Clones {
function clone(address implementation) internal returns (address instance) {
assembly {
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create(0, 0x09, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
assembly {
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create2(0, 0x09, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x38), deployer)
mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
mstore(add(ptr, 0x14), implementation)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
mstore(add(ptr, 0x58), salt)
mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
predicted := keccak256(add(ptr, 0x43), 0x55)
}
}
function predictDeterministicAddress(address implementation, bytes32 salt)
internal
view
returns (address predicted)
{
return predictDeterministicAddress(implementation, salt, address(this));
}
}
文件 5 的 27：ConnectorRegistry.sol
pragma solidity ^0.8.17;
import { Admin } from "contracts/base/Admin.sol";
import { TimelockAdmin } from "contracts/base/TimelockAdmin.sol";
error ConnectorNotRegistered(address target);
interface ICustomConnectorRegistry {
function connectorOf(address target) external view returns (address);
}
contract ConnectorRegistry is Admin, TimelockAdmin {
event ConnectorChanged(address target, address connector);
event CustomRegistryAdded(address registry);
event CustomRegistryRemoved(address registry);
error ConnectorAlreadySet(address target);
error ConnectorNotSet(address target);
ICustomConnectorRegistry[] public customRegistries;
mapping(ICustomConnectorRegistry => bool) public isCustomRegistry;
mapping(address target => address connector) private connectors_;
constructor(
address admin_,
address timelockAdmin_
) Admin(admin_) TimelockAdmin(timelockAdmin_) { }
function setConnectors(
address[] calldata targets,
address[] calldata connectors
) external onlyAdmin {
for (uint256 i; i != targets.length;) {
if (connectors_[targets[i]] != address(0)) {
revert ConnectorAlreadySet(targets[i]);
}
connectors_[targets[i]] = connectors[i];
emit ConnectorChanged(targets[i], connectors[i]);
unchecked {
++i;
}
}
}
function updateConnectors(
address[] calldata targets,
address[] calldata connectors
) external onlyTimelockAdmin {
for (uint256 i; i != targets.length;) {
if (connectors_[targets[i]] == address(0)) {
revert ConnectorNotSet(targets[i]);
}
connectors_[targets[i]] = connectors[i];
emit ConnectorChanged(targets[i], connectors[i]);
unchecked {
++i;
}
}
}
function addCustomRegistry(ICustomConnectorRegistry registry)
external
onlyAdmin
{
customRegistries.push(registry);
isCustomRegistry[registry] = true;
emit CustomRegistryAdded(address(registry));
}
function updateCustomRegistry(
uint256 index,
ICustomConnectorRegistry newRegistry
) external onlyTimelockAdmin {
address oldRegistry = address(customRegistries[index]);
isCustomRegistry[customRegistries[index]] = false;
emit CustomRegistryRemoved(oldRegistry);
customRegistries[index] = newRegistry;
isCustomRegistry[newRegistry] = true;
if (address(newRegistry) != address(0)) {
emit CustomRegistryAdded(address(newRegistry));
}
}
function connectorOf(address target) external view returns (address) {
address connector = connectors_[target];
if (connector != address(0)) {
return connector;
}
uint256 length = customRegistries.length;
for (uint256 i; i != length;) {
if (address(customRegistries[i]) != address(0)) {
try customRegistries[i].connectorOf(target) returns (
address _connector
) {
if (_connector != address(0)) {
return _connector;
}
} catch {
}
}
unchecked {
++i;
}
}
revert ConnectorNotRegistered(target);
}
function hasConnector(address target) external view returns (bool) {
if (connectors_[target] != address(0)) {
return true;
}
uint256 length = customRegistries.length;
for (uint256 i; i != length;) {
if (address(customRegistries[i]) != address(0)) {
try customRegistries[i].connectorOf(target) returns (
address _connector
) {
if (_connector != address(0)) {
return true;
}
} catch {
}
unchecked {
++i;
}
}
}
return false;
}
}
文件 6 的 27：DelegateModule.sol
pragma solidity ^0.8.17;
contract DelegateModule {
function _delegateTo(
address to,
bytes memory data
) internal returns (bytes memory) {
(bool success, bytes memory result) = to.delegatecall(data);
if (!success) {
if (result.length == 0) revert();
assembly {
revert(add(32, result), mload(result))
}
}
return result;
}
}
文件 7 的 27：ERC20.sol
pragma solidity >=0.8.0;
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
unchecked {
address recoveredAddress = ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)
)
);
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
文件 8 的 27：FeesLib.sol
pragma solidity ^0.8.17;
import { SafeTransferLib } from "solmate/utils/SafeTransferLib.sol";
import { WETH } from "solmate/tokens/WETH.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { Sickle } from "contracts/Sickle.sol";
import { SickleRegistry } from "contracts/SickleRegistry.sol";
contract FeesLib {
event FeeCharged(
address strategy, bytes4 feeDescriptor, uint256 amount, address token
);
event TransactionCostCharged(address recipient, uint256 amount);
uint256 public constant VERSION = 1;
SickleRegistry public immutable registry;
WETH public immutable weth;
address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
constructor(SickleRegistry registry_, WETH weth_) {
registry = registry_;
weth = weth_;
}
function chargeFee(
address strategy,
bytes4 feeDescriptor,
address feeToken,
uint256 feeBasis
) public payable returns (uint256 remainder) {
uint256 fee = registry.feeRegistry(
keccak256(abi.encodePacked(strategy, feeDescriptor))
);
if (feeBasis == 0) {
if (feeToken == ETH) {
uint256 wethBalance = weth.balanceOf(address(this));
if (wethBalance > 0) {
weth.withdraw(wethBalance);
}
feeBasis = address(this).balance;
} else {
feeBasis = IERC20(feeToken).balanceOf(address(this));
}
}
if (fee == 0) {
return feeBasis;
}
uint256 amountToCharge = feeBasis * fee / 10_000;
if (feeToken == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
SafeTransferLib.safeTransferETH(
registry.collector(), amountToCharge
);
} else {
SafeTransferLib.safeTransfer(
feeToken, registry.collector(), amountToCharge
);
}
emit FeeCharged(strategy, feeDescriptor, amountToCharge, feeToken);
return feeBasis - amountToCharge;
}
function chargeFees(
address strategy,
bytes4 feeDescriptor,
address[] memory feeTokens
) external {
for (uint256 i = 0; i < feeTokens.length;) {
chargeFee(strategy, feeDescriptor, feeTokens[i], 0);
unchecked {
i++;
}
}
}
function getBalance(
Sickle sickle,
address token
) public view returns (uint256) {
if (token == ETH) {
return weth.balanceOf(address(sickle));
}
return IERC20(token).balanceOf(address(sickle));
}
}
文件 9 的 27：IERC1155.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 10 的 27：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 11 的 27：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
文件 12 的 27：IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
文件 13 的 27：IFarmConnector.sol
pragma solidity ^0.8.0;
interface IFarmConnector {
function deposit(
address target,
address token,
bytes memory extraData
) external payable;
function withdraw(
address target,
uint256 amount,
bytes memory extraData
) external;
function claim(address target, bytes memory extraData) external;
}
文件 14 的 27：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/Address.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
文件 15 的 27：MsgValueModule.sol
pragma solidity ^0.8.17;
contract MsgValueModule {
error IncorrectMsgValue();
function _checkMsgValue(uint256 inputAmount, bool isNative) internal {
if (
(isNative && inputAmount != msg.value)
|| (!isNative && msg.value > 0)
) {
revert IncorrectMsgValue();
}
}
}
文件 16 的 27：Multicall.sol
pragma solidity ^0.8.17;
import { SickleStorage } from "contracts/base/SickleStorage.sol";
import { SickleRegistry } from "contracts/SickleRegistry.sol";
abstract contract Multicall is SickleStorage {
error MulticallParamsMismatchError();
error TargetNotWhitelisted(address target);
error CallerNotWhitelisted(address caller);
SickleRegistry public immutable registry;
constructor(SickleRegistry registry_) initializer {
registry = registry_;
}
function multicall(
address[] calldata targets,
bytes[] calldata data
) external payable {
if (targets.length != data.length) {
revert MulticallParamsMismatchError();
}
if (!registry.isWhitelistedCaller(msg.sender)) {
revert CallerNotWhitelisted(msg.sender);
}
for (uint256 i = 0; i != data.length;) {
if (targets[i] == address(0)) {
unchecked {
++i;
}
continue;
}
if (targets[i] != address(this)) {
if (!registry.isWhitelistedTarget(targets[i])) {
revert TargetNotWhitelisted(targets[i]);
}
}
(bool success, bytes memory result) =
targets[i].delegatecall(data[i]);
if (!success) {
if (result.length == 0) revert();
assembly {
revert(add(32, result), mload(result))
}
}
unchecked {
++i;
}
}
}
}
文件 17 的 27：NftFarmStrategy.sol
pragma solidity ^0.8.17;
import { NftTransferLib } from "contracts/libraries/NftTransferLib.sol";
import { FeesLib } from "contracts/libraries/FeesLib.sol";
import { TransferLib } from "contracts/libraries/TransferLib.sol";
import {
StrategyModule,
SickleFactory,
Sickle
} from "contracts/modules/StrategyModule.sol";
import { IFarmConnector } from "contracts/interfaces/IFarmConnector.sol";
import { ConnectorRegistry } from "contracts/ConnectorRegistry.sol";
library NftFarmStrategyFees {
bytes4 constant Harvest = bytes4(keccak256("FarmHarvestFee"));
}
contract NftFarmStrategy is StrategyModule {
struct Libraries {
NftTransferLib nftTransferLib;
FeesLib feesLib;
TransferLib transferLib;
}
NftTransferLib public immutable nftTransferLib;
FeesLib public immutable feesLib;
TransferLib public immutable transferLib;
address public immutable strategyAddress;
constructor(
SickleFactory factory,
ConnectorRegistry connectorRegistry,
Libraries memory libraries
) StrategyModule(factory, connectorRegistry) {
nftTransferLib = libraries.nftTransferLib;
feesLib = libraries.feesLib;
transferLib = libraries.transferLib;
strategyAddress = address(this);
}
function depositErc721(
address nftContractAddress,
uint256 tokenId,
address stakingContractAddress,
bytes memory extraData,
address approved,
bytes32 referralCode
) public {
Sickle sickle = getOrDeploySickle(msg.sender, approved, referralCode);
address farmConnector =
connectorRegistry.connectorOf(stakingContractAddress);
address[] memory targets = new address[](2);
bytes[] memory data = new bytes[](2);
targets[0] = address(nftTransferLib);
data[0] = abi.encodeCall(
NftTransferLib.transferErc721FromUser, (nftContractAddress, tokenId)
);
targets[1] = farmConnector;
data[1] = abi.encodeCall(
IFarmConnector.deposit,
(stakingContractAddress, nftContractAddress, extraData)
);
sickle.multicall(targets, data);
}
function withdrawErc721(
address nftContractAddress,
uint256 tokenId,
address stakingContractAddress,
bytes memory extraData,
address[] calldata rewardTokens
) public {
Sickle sickle = getSickle(msg.sender);
address[] memory targets = new address[](5);
bytes[] memory data = new bytes[](5);
address farmConnector =
connectorRegistry.connectorOf(stakingContractAddress);
targets[0] = farmConnector;
data[0] = abi.encodeCall(
IFarmConnector.claim, (stakingContractAddress, extraData)
);
targets[1] = farmConnector;
data[1] = abi.encodeCall(
IFarmConnector.withdraw,
(stakingContractAddress, tokenId, extraData)
);
targets[2] = address(nftTransferLib);
data[2] = abi.encodeCall(
NftTransferLib.transferErc721ToUser, (nftContractAddress, tokenId)
);
targets[3] = address(feesLib);
data[3] = abi.encodeCall(
FeesLib.chargeFees,
(strategyAddress, NftFarmStrategyFees.Harvest, rewardTokens)
);
targets[4] = address(transferLib);
data[4] =
abi.encodeCall(TransferLib.transferTokensToUser, (rewardTokens));
sickle.multicall(targets, data);
}
}
文件 18 的 27：NftTransferLib.sol
pragma solidity ^0.8.17;
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { IERC1155 } from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import { Sickle } from "contracts/Sickle.sol";
contract NftTransferLib {
function transferErc721FromUser(
address nftContractAddress,
uint256 tokenId
) external {
IERC721(nftContractAddress).safeTransferFrom(
Sickle(payable(address(this))).owner(), address(this), tokenId
);
}
function transferErc721ToUser(
address nftContractAddress,
uint256 tokenId
) external {
IERC721(nftContractAddress).safeTransferFrom(
address(this), Sickle(payable(address(this))).owner(), tokenId
);
}
function transferErc1155FromUser(
address nftContractAddress,
uint256 tokenId,
uint256 amount
) external {
IERC1155(nftContractAddress).safeTransferFrom(
Sickle(payable(address(this))).owner(),
address(this),
tokenId,
amount,
""
);
}
function transferErc1155ToUser(
address nftContractAddress,
uint256 tokenId,
uint256 amount
) external {
IERC1155(nftContractAddress).safeTransferFrom(
address(this),
Sickle(payable(address(this))).owner(),
tokenId,
amount,
""
);
}
}
文件 19 的 27：SafeTransferLib.sol
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
library SafeTransferLib {
error ETHTransferFailed();
error TransferFromFailed();
error TransferFailed();
error ApproveFailed();
function safeTransferETH(address to, uint256 amount) internal {
bool success;
assembly {
success := call(gas(), to, amount, 0, 0, 0, 0)
}
if (!success) revert ETHTransferFailed();
}
function safeTransferFrom(
address token,
address from,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), from)
mstore(add(freeMemoryPointer, 36), to)
mstore(add(freeMemoryPointer, 68), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
)
}
if (!success) revert TransferFromFailed();
}
function safeTransfer(
address token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
if (!success) revert TransferFailed();
}
function safeApprove(
address token,
address to,
uint256 amount
) internal {
bool success;
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to)
mstore(add(freeMemoryPointer, 36), amount)
success := and(
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
if (!success) revert ApproveFailed();
}
}
文件 20 的 27：Sickle.sol
pragma solidity ^0.8.17;
import { SickleStorage } from "contracts/base/SickleStorage.sol";
import { Multicall } from "contracts/base/Multicall.sol";
import { SickleRegistry } from "contracts/SickleRegistry.sol";
contract Sickle is SickleStorage, Multicall {
receive() external payable { }
constructor(SickleRegistry sickleRegistry_)
initializer
Multicall(sickleRegistry_)
{
_Sickle_initialize(address(0), address(0));
}
function initialize(
address sickleOwner_,
address approved_
) external initializer {
_Sickle_initialize(sickleOwner_, approved_);
}
function _Sickle_initialize(
address sickleOwner_,
address approved_
) internal {
SickleStorage._SickleStorage_initialize(sickleOwner_, approved_);
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure returns (bytes4) {
return this.onERC721Received.selector;
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure returns (bytes4) {
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure returns (bytes4) {
return this.onERC1155BatchReceived.selector;
}
}
文件 21 的 27：SickleFactory.sol
pragma solidity ^0.8.17;
import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";
import { SickleRegistry } from "contracts/SickleRegistry.sol";
import { Sickle } from "contracts/Sickle.sol";
import { Admin } from "contracts/base/Admin.sol";
contract SickleFactory is Admin {
event Deploy(address indexed admin, address sickle);
error CallerNotWhitelisted(address caller);
error NotActive();
error SickleAlreadyDeployed();
mapping(address => address) private _sickles;
mapping(address => address) private _admins;
mapping(address => bytes32) public _referralCodes;
SickleRegistry public immutable registry;
address public immutable implementation;
SickleFactory public immutable previousFactory;
bool public isActive = true;
constructor(
address admin_,
address sickleRegistry_,
address sickleImplementation_,
address previousFactory_
) Admin(admin_) {
registry = SickleRegistry(sickleRegistry_);
implementation = sickleImplementation_;
previousFactory = SickleFactory(previousFactory_);
}
function setActive(bool active) external onlyAdmin {
isActive = active;
}
function _deploy(
address admin,
address approved,
bytes32 referralCode
) internal returns (address sickle) {
sickle = Clones.cloneDeterministic(
implementation, keccak256(abi.encode(admin))
);
Sickle(payable(sickle)).initialize(admin, approved);
_sickles[admin] = sickle;
_admins[sickle] = admin;
if (referralCode != bytes32(0)) {
_referralCodes[sickle] = referralCode;
}
emit Deploy(admin, sickle);
}
function _getSickle(address admin) internal returns (address sickle) {
sickle = _sickles[admin];
if (sickle != address(0)) {
return sickle;
}
if (address(previousFactory) != address(0)) {
sickle = previousFactory.sickles(admin);
if (sickle != address(0)) {
_sickles[admin] = sickle;
_admins[sickle] = admin;
_referralCodes[sickle] = previousFactory.referralCodes(sickle);
return sickle;
}
}
}
function predict(address admin) external view returns (address) {
bytes32 salt = keccak256(abi.encode(admin));
return Clones.predictDeterministicAddress(implementation, salt);
}
function sickles(address admin) external view returns (address sickle) {
sickle = _sickles[admin];
if (sickle == address(0) && address(previousFactory) != address(0)) {
sickle = previousFactory.sickles(admin);
}
}
function admins(address sickle) external view returns (address admin) {
admin = _admins[sickle];
if (admin == address(0) && address(previousFactory) != address(0)) {
admin = previousFactory.admins(sickle);
}
}
function referralCodes(address sickle)
external
view
returns (bytes32 referralCode)
{
referralCode = _referralCodes[sickle];
if (
referralCode == bytes32(0) && address(previousFactory) != address(0)
) {
referralCode = previousFactory.referralCodes(sickle);
}
}
function getOrDeploy(
address admin,
address approved,
bytes32 referralCode
) external returns (address sickle) {
if (!isActive) {
revert NotActive();
}
if (!registry.isWhitelistedCaller(msg.sender)) {
revert CallerNotWhitelisted(msg.sender);
}
if ((sickle = _getSickle(admin)) != address(0)) {
return sickle;
}
return _deploy(admin, approved, referralCode);
}
function deploy(
address approved,
bytes32 referralCode
) external returns (address sickle) {
if (!isActive) {
revert NotActive();
}
if (_getSickle(msg.sender) != address(0)) {
revert SickleAlreadyDeployed();
}
return _deploy(msg.sender, approved, referralCode);
}
}
文件 22 的 27：SickleRegistry.sol
pragma solidity ^0.8.17;
import { Admin } from "contracts/base/Admin.sol";
library SickleRegistryEvents {
event CollectorChanged(address newCollector);
event FeesUpdated(bytes32[] feeHashes, uint256[] feesInBP);
event ReferralCodeCreated(bytes32 indexed code, address indexed referrer);
event CallerStatusChanged(address caller, bool isWhitelisted);
event TargetStatusChanged(address target, bool isWhitelisted);
}
contract SickleRegistry is Admin {
error ArrayLengthMismatch();
error FeeAboveMaxLimit();
error InvalidReferralCode();
address public collector;
mapping(address => bool) public isWhitelistedTarget;
mapping(address => bool) public isWhitelistedCaller;
mapping(bytes32 => address) public referralCodes;
mapping(bytes32 => uint256) public feeRegistry;
constructor(address admin_, address collector_) Admin(admin_) {
collector = collector_;
}
function setWhitelistedTargets(
address[] calldata targets,
bool isApproved
) external onlyAdmin {
for (uint256 i; i < targets.length;) {
isWhitelistedTarget[targets[i]] = isApproved;
emit SickleRegistryEvents.TargetStatusChanged(
targets[i], isApproved
);
unchecked {
++i;
}
}
}
function updateCollector(address newCollector) external onlyAdmin {
collector = newCollector;
emit SickleRegistryEvents.CollectorChanged(newCollector);
}
function setWhitelistedCallers(
address[] calldata callers,
bool isApproved
) external onlyAdmin {
for (uint256 i; i < callers.length;) {
isWhitelistedCaller[callers[i]] = isApproved;
emit SickleRegistryEvents.CallerStatusChanged(
callers[i], isApproved
);
unchecked {
++i;
}
}
}
function setReferralCode(bytes32 referralCode) external {
if (referralCodes[referralCode] != address(0)) {
revert InvalidReferralCode();
}
referralCodes[referralCode] = msg.sender;
emit SickleRegistryEvents.ReferralCodeCreated(referralCode, msg.sender);
}
function setFees(
bytes32[] calldata feeHashes,
uint256[] calldata feesArray
) external onlyAdmin {
if (feeHashes.length != feesArray.length) {
revert ArrayLengthMismatch();
}
for (uint256 i = 0; i < feeHashes.length;) {
if (feesArray[i] <= 500) {
feeRegistry[feeHashes[i]] = feesArray[i];
} else {
revert FeeAboveMaxLimit();
}
unchecked {
++i;
}
}
emit SickleRegistryEvents.FeesUpdated(feeHashes, feesArray);
}
}
文件 23 的 27：SickleStorage.sol
pragma solidity ^0.8.17;
import { Initializable } from
"@openzeppelin/contracts/proxy/utils/Initializable.sol";
library SickleStorageEvents {
event ApprovedAddressChanged(address newApproved);
}
abstract contract SickleStorage is Initializable {
error NotOwnerError();
error NotStrategyError();
address public owner;
address public approved;
modifier onlyOwner() {
if (msg.sender != owner) revert NotOwnerError();
_;
}
function _SickleStorage_initialize(
address owner_,
address approved_
) internal onlyInitializing {
owner = owner_;
approved = approved_;
}
function setApproved(address newApproved) external onlyOwner {
approved = newApproved;
emit SickleStorageEvents.ApprovedAddressChanged(newApproved);
}
function isOwnerOrApproved(address caller) public view returns (bool) {
return caller == owner || caller == approved;
}
}
文件 24 的 27：StrategyModule.sol
pragma solidity ^0.8.17;
import { SickleFactory, Sickle } from "contracts/SickleFactory.sol";
import { ConnectorRegistry } from "contracts/ConnectorRegistry.sol";
import { AccessControlModule } from "contracts/modules/AccessControlModule.sol";
contract StrategyModule is AccessControlModule {
ConnectorRegistry public immutable connectorRegistry;
constructor(
SickleFactory factory,
ConnectorRegistry connectorRegistry_
) AccessControlModule(factory) {
connectorRegistry = connectorRegistry_;
}
function getSickle(address owner) public view returns (Sickle) {
Sickle sickle = Sickle(payable(factory.sickles(owner)));
if (address(sickle) == address(0)) {
revert SickleNotDeployed();
}
return sickle;
}
function getOrDeploySickle(
address owner,
address approved,
bytes32 referralCode
) public returns (Sickle) {
return
Sickle(payable(factory.getOrDeploy(owner, approved, referralCode)));
}
}
文件 25 的 27：TimelockAdmin.sol
pragma solidity ^0.8.17;
abstract contract TimelockAdmin {
error NotTimelockAdminError();
event TimelockAdminSet(address oldTimelockAdmin, address newTimelockAdmin);
address public timelockAdmin;
modifier onlyTimelockAdmin() {
if (msg.sender != timelockAdmin) revert NotTimelockAdminError();
_;
}
constructor(address timelockAdmin_) {
emit TimelockAdminSet(timelockAdmin, timelockAdmin_);
timelockAdmin = timelockAdmin_;
}
function setTimelockAdmin(address newTimelockAdmin)
external
onlyTimelockAdmin
{
emit TimelockAdminSet(timelockAdmin, newTimelockAdmin);
timelockAdmin = newTimelockAdmin;
}
}
文件 26 的 27：TransferLib.sol
pragma solidity ^0.8.17;
import { MsgValueModule } from "contracts/modules/MsgValueModule.sol";
import { WETH } from "lib/solmate/src/tokens/WETH.sol";
import { Sickle } from "contracts/Sickle.sol";
import { SafeTransferLib } from "lib/solmate/src/utils/SafeTransferLib.sol";
import { IERC20 } from
"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol";
import { FeesLib } from "contracts/libraries/FeesLib.sol";
import { DelegateModule } from "contracts/modules/DelegateModule.sol";
contract TransferLib is MsgValueModule, DelegateModule {
error ArrayLengthMismatch();
error TokenInRequired();
address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
WETH public immutable weth;
FeesLib public immutable feesLib;
constructor(FeesLib feseLib_, WETH weth_) {
feesLib = feseLib_;
weth = weth_;
}
function transferTokenToUser(address token) public payable {
address recipient = Sickle(payable(address(this))).owner();
if (token == address(0)) {
return;
}
if (token == ETH) {
uint256 wethBalance = weth.balanceOf(address(this));
if (wethBalance > 0) {
weth.withdraw(wethBalance);
}
if (address(this).balance > 0) {
SafeTransferLib.safeTransferETH(
recipient, address(this).balance
);
}
} else {
uint256 balance = IERC20(token).balanceOf(address(this));
if (balance > 0) {
SafeTransferLib.safeTransfer(token, recipient, balance);
}
}
}
function transferTokensToUser(address[] memory tokens) external payable {
for (uint256 i = 0; i != tokens.length;) {
transferTokenToUser(tokens[i]);
unchecked {
i++;
}
}
}
function transferTokenFromUser(
address tokenIn,
uint256 amountIn,
address strategy,
bytes4 feeSelector
) public payable {
_checkMsgValue(amountIn, tokenIn == ETH);
_transferTokenFromUser(tokenIn, amountIn, strategy, feeSelector);
}
function transferTokensFromUser(
address[] memory tokensIn,
uint256[] memory amountsIn,
address strategy,
bytes4 feeSelector
) external payable {
if (tokensIn.length != amountsIn.length) {
revert ArrayLengthMismatch();
}
if (tokensIn.length == 0) {
revert TokenInRequired();
}
bool hasEth = false;
for (uint256 i = 0; i < tokensIn.length; i++) {
if (tokensIn[i] == ETH) {
_checkMsgValue(amountsIn[i], true);
hasEth = true;
}
_transferTokenFromUser(
tokensIn[i], amountsIn[i], strategy, feeSelector
);
}
if (!hasEth) {
_checkMsgValue(0, false);
}
}
function _transferTokenFromUser(
address tokenIn,
uint256 amountIn,
address strategy,
bytes4 feeSelector
) internal {
if (tokenIn != ETH) {
SafeTransferLib.safeTransferFrom(
tokenIn,
Sickle(payable(address(this))).owner(),
address(this),
amountIn
);
}
bytes memory result = _delegateTo(
address(feesLib),
abi.encodeCall(
FeesLib.chargeFee, (strategy, feeSelector, tokenIn, 0)
)
);
uint256 remainder = abi.decode(result, (uint256));
if (tokenIn == ETH) {
weth.deposit{ value: remainder }();
}
}
}
文件 27 的 27：WETH.sol
pragma solidity >=0.8.0;
import {ERC20} from "./ERC20.sol";
import {SafeTransferLib} from "../utils/SafeTransferLib.sol";
contract WETH is ERC20("Wrapped Ether", "WETH", 18) {
using SafeTransferLib for address;
event Deposit(address indexed from, uint256 amount);
event Withdrawal(address indexed to, uint256 amount);
function deposit() public payable virtual {
_mint(msg.sender, msg.value);
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint256 amount) public virtual {
_burn(msg.sender, amount);
emit Withdrawal(msg.sender, amount);
msg.sender.safeTransferETH(amount);
}
receive() external payable virtual {
deposit();
}
}
{
"compilationTarget": {
"contracts/strategies/NftFarmStrategy.sol": "NftFarmStrategy"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@morpho-blue/=lib/morpho-blue/src/",
":@openzeppelin/=lib/openzeppelin-contracts/",
":@uniswap/v3-core/=lib/v3-core/",
":@uniswap/v3-periphery/=lib/v3-periphery/",
":ds-test/=lib/solmate/lib/ds-test/src/",
":forge-std/=lib/forge-std/src/",
":morpho-blue/=lib/morpho-blue/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":solmate/=lib/solmate/src/"
]
}[{"inputs":[{"internalType":"contract SickleFactory","name":"factory","type":"address"},{"internalType":"contract ConnectorRegistry","name":"connectorRegistry","type":"address"},{"components":[{"internalType":"contract NftTransferLib","name":"nftTransferLib","type":"address"},{"internalType":"contract FeesLib","name":"feesLib","type":"address"},{"internalType":"contract TransferLib","name":"transferLib","type":"address"}],"internalType":"struct NftFarmStrategy.Libraries","name":"libraries","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"NotOwner","type":"error"},{"inputs":[],"name":"NotOwnerOrApproved","type":"error"},{"inputs":[],"name":"NotOwnerOrApprovedOrInternal","type":"error"},{"inputs":[],"name":"NotOwnerOrInternal","type":"error"},{"inputs":[],"name":"NotRegisteredSickle","type":"error"},{"inputs":[],"name":"SickleNotDeployed","type":"error"},{"inputs":[],"name":"connectorRegistry","outputs":[{"internalType":"contract ConnectorRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nftContractAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"stakingContractAddress","type":"address"},{"internalType":"bytes","name":"extraData","type":"bytes"},{"internalType":"address","name":"approved","type":"address"},{"internalType":"bytes32","name":"referralCode","type":"bytes32"}],"name":"depositErc721","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract SickleFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feesLib","outputs":[{"internalType":"contract FeesLib","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"approved","type":"address"},{"internalType":"bytes32","name":"referralCode","type":"bytes32"}],"name":"getOrDeploySickle","outputs":[{"internalType":"contract Sickle","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getSickle","outputs":[{"internalType":"contract Sickle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftTransferLib","outputs":[{"internalType":"contract NftTransferLib","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"strategyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transferLib","outputs":[{"internalType":"contract TransferLib","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nftContractAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"stakingContractAddress","type":"address"},{"internalType":"bytes","name":"extraData","type":"bytes"},{"internalType":"address[]","name":"rewardTokens","type":"address[]"}],"name":"withdrawErc721","outputs":[],"stateMutability":"nonpayable","type":"function"}]
